cleanup

41 files changed, 1086 insertions, 0 deletions

diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@@compile.erl b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@@compile.erl
new file mode 100644
index 0000000..543db88
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@@compile.erl
@@ -0,0 +1,157 @@
+#!/usr/bin/env escript
+
+% TODO: Don't concurrently print warnings and errors
+% TODO: Some tests
+
+-record(arguments, {lib = "./", out = "./", modules = []}).
+
+main(Args) ->
+    #arguments{out = Out, lib = Lib, modules = Modules} = parse(Args),
+    IsElixirModule = fun(Module) ->
+        filename:extension(Module) =:= ".ex"
+    end,
+    {ElixirModules, ErlangModules} = lists:partition(IsElixirModule, Modules),
+    ok = configure_logging(),
+    ok = add_lib_to_erlang_path(Lib),
+    ok = filelib:ensure_dir([Out, $/]),
+    {ErlangOk, _ErlangBeams} = compile_erlang(ErlangModules, Out),
+    {ElixirOk, _ElixirBeams} = case ErlangOk of
+        true -> compile_elixir(ElixirModules, Out);
+        false -> {false, []}
+    end,
+    case ErlangOk and ElixirOk of
+        true -> ok;
+        false -> erlang:halt(1)
+    end.
+
+compile_erlang(Modules, Out) ->
+    Workers = start_compiler_workers(Out),
+    ok = producer_loop(Modules, Workers),
+    collect_results({true, []}).
+
+collect_results(Acc = {Result, Beams}) ->
+    receive
+        {compiled, Beam} -> collect_results({Result, [Beam | Beams]});
+        failed -> collect_results({false, Beams})
+        after 0 -> Acc
+    end.
+
+producer_loop([], 0) ->
+    ok;
+producer_loop([], Workers) ->
+    receive
+        {work_please, _} -> producer_loop([], Workers - 1)
+    end;
+producer_loop([Module | Modules], Workers) ->
+    receive
+        {work_please, Worker} ->
+            erlang:send(Worker, {module, Module}),
+            producer_loop(Modules, Workers)
+    end.
+
+start_compiler_workers(Out) ->
+    Parent = self(),
+    NumSchedulers = erlang:system_info(schedulers),
+    SpawnWorker = fun(_) ->
+        erlang:spawn_link(fun() -> worker_loop(Parent, Out) end)
+    end,
+    lists:foreach(SpawnWorker, lists:seq(1, NumSchedulers)),
+    NumSchedulers.
+
+worker_loop(Parent, Out) ->
+    Options = [report_errors, report_warnings, debug_info, {outdir, Out}],
+    erlang:send(Parent, {work_please, self()}),
+    receive
+        {module, Module} ->
+            log({compiling, Module}),
+            case compile:file(Module, Options) of
+                {ok, ModuleName} ->
+                    Beam = filename:join(Out, ModuleName) ++ ".beam",
+                    Message = {compiled, Beam},
+                    log(Message),
+                    erlang:send(Parent, Message);
+                error ->
+                    log({failed, Module}),
+                    erlang:send(Parent, failed)
+            end,
+            worker_loop(Parent, Out)
+    end.
+
+compile_elixir(Modules, Out) ->
+    Error = [
+        "The program elixir was not found. Is it installed?",
+        $\n,
+        "Documentation for installing Elixir can be viewed here:",
+        $\n,
+        "https://elixir-lang.org/install.html"
+    ],
+    case Modules of
+        [] -> {true, []};
+        _ ->
+            log({starting, "compiler.app"}),
+            ok = application:start(compiler),
+            log({starting, "elixir.app"}),
+            case application:start(elixir) of
+                ok -> do_compile_elixir(Modules, Out);
+                _ ->
+                    io:put_chars(standard_error, [Error, $\n]),
+                    {false, []}
+            end
+    end.
+
+do_compile_elixir(Modules, Out) ->
+    ModuleBins = lists:map(fun(Module) ->
+        log({compiling, Module}),
+        list_to_binary(Module)
+    end, Modules),
+    OutBin = list_to_binary(Out),
+    Options = [{dest, OutBin}],
+    % Silence "redefining module" warnings.
+    % Compiled modules in the build directory are added to the code path.
+    % These warnings result from recompiling loaded modules.
+    % TODO: This line can likely be removed if/when the build directory is cleaned before every compilation.
+    'Elixir.Code':compiler_options([{ignore_module_conflict, true}]),
+    case 'Elixir.Kernel.ParallelCompiler':compile_to_path(ModuleBins, OutBin, Options) of
+        {ok, ModuleAtoms, _} ->
+            ToBeam = fun(ModuleAtom) ->
+                Beam = filename:join(Out, atom_to_list(ModuleAtom)) ++ ".beam",
+                log({compiled, Beam}),
+                Beam
+            end,
+            {true, lists:map(ToBeam, ModuleAtoms)};
+        {error, Errors, _} ->
+            % Log all filenames associated with modules that failed to compile.
+            % Note: The compiler prints compilation errors upon encountering them.
+            ErrorFiles = lists:usort([File || {File, _, _} <- Errors]),
+            Log = fun(File) ->
+                log({failed, binary_to_list(File)})
+            end,
+            lists:foreach(Log, ErrorFiles),
+            {false, []};
+        _ -> {false, []}
+    end.
+
+add_lib_to_erlang_path(Lib) ->
+    code:add_paths(filelib:wildcard([Lib, "/*/ebin"])).
+
+parse(Args) ->
+    parse(Args, #arguments{}).
+
+parse([], Arguments) ->
+    Arguments;
+parse(["--lib", Lib | Rest], Arguments) ->
+    parse(Rest, Arguments#arguments{lib = Lib});
+parse(["--out", Out | Rest], Arguments) ->
+    parse(Rest, Arguments#arguments{out = Out});
+parse([Module | Rest], Arguments = #arguments{modules = Modules}) ->
+    parse(Rest, Arguments#arguments{modules = [Module | Modules]}).
+
+configure_logging() ->
+    Enabled = os:getenv("GLEAM_LOG") /= false,
+    persistent_term:put(gleam_logging_enabled, Enabled).
+
+log(Term) ->
+    case persistent_term:get(gleam_logging_enabled) of
+        true -> erlang:display(Term), ok;
+        false -> ok
+    end.
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@actor.cache b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@actor.cache
new file mode 100644
index 0000000..5aa9880
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@actor.cache
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@actor.cache_meta b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@actor.cache_meta
new file mode 100644
index 0000000..d5f2a3e
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@actor.cache_meta
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@actor.erl b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@actor.erl
new file mode 100644
index 0000000..9b215cb
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@actor.erl
@@ -0,0 +1,273 @@
+-module(gleam@otp@actor).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function]).
+
+-export([continue/1, with_selector/2, to_erlang_start_result/1, start_spec/1, start/2, send/2, call/3]).
+-export_type([message/1, next/2, init_result/2, self/2, spec/2, start_error/0, start_init_message/1]).
+
+-type message(LTB) :: {message, LTB} |
+    {system, gleam@otp@system:system_message()} |
+    {unexpected, gleam@dynamic:dynamic_()}.
+
+-type next(LTC, LTD) :: {continue,
+        LTD,
+        gleam@option:option(gleam@erlang@process:selector(LTC))} |
+    {stop, gleam@erlang@process:exit_reason()}.
+
+-type init_result(LTE, LTF) :: {ready, LTE, gleam@erlang@process:selector(LTF)} |
+    {failed, binary()}.
+
+-type self(LTG, LTH) :: {self,
+        gleam@otp@system:mode(),
+        gleam@erlang@process:pid_(),
+        LTG,
+        gleam@erlang@process:subject(LTH),
+        gleam@erlang@process:selector(message(LTH)),
+        gleam@otp@system:debug_state(),
+        fun((LTH, LTG) -> next(LTH, LTG))}.
+
+-type spec(LTI, LTJ) :: {spec,
+        fun(() -> init_result(LTI, LTJ)),
+        integer(),
+        fun((LTJ, LTI) -> next(LTJ, LTI))}.
+
+-type start_error() :: init_timeout |
+    {init_failed, gleam@erlang@process:exit_reason()} |
+    {init_crashed, gleam@dynamic:dynamic_()}.
+
+-type start_init_message(LTK) :: {ack,
+        {ok, gleam@erlang@process:subject(LTK)} |
+            {error, gleam@erlang@process:exit_reason()}} |
+    {mon, gleam@erlang@process:process_down()}.
+
+-spec continue(LTR) -> next(any(), LTR).
+continue(State) ->
+    {continue, State, none}.
+
+-spec with_selector(next(LTV, LTW), gleam@erlang@process:selector(LTV)) -> next(LTV, LTW).
+with_selector(Value, Selector) ->
+    case Value of
+        {continue, State, _} ->
+            {continue, State, {some, Selector}};
+
+        _ ->
+            Value
+    end.
+
+-spec exit_process(gleam@erlang@process:exit_reason()) -> gleam@erlang@process:exit_reason().
+exit_process(Reason) ->
+    Reason.
+
+-spec selecting_system_messages(gleam@erlang@process:selector(message(LUH))) -> gleam@erlang@process:selector(message(LUH)).
+selecting_system_messages(Selector) ->
+    _pipe = Selector,
+    gleam@erlang@process:selecting_record3(
+        _pipe,
+        erlang:binary_to_atom(<<"system"/utf8>>),
+        fun gleam_otp_external:convert_system_message/2
+    ).
+
+-spec receive_message(self(any(), LUD)) -> message(LUD).
+receive_message(Self) ->
+    Selector = case erlang:element(2, Self) of
+        suspended ->
+            _pipe = gleam_erlang_ffi:new_selector(),
+            selecting_system_messages(_pipe);
+
+        running ->
+            _pipe@1 = gleam_erlang_ffi:new_selector(),
+            _pipe@2 = gleam@erlang@process:selecting_anything(
+                _pipe@1,
+                fun(Field@0) -> {unexpected, Field@0} end
+            ),
+            _pipe@3 = gleam_erlang_ffi:merge_selector(
+                _pipe@2,
+                erlang:element(6, Self)
+            ),
+            selecting_system_messages(_pipe@3)
+    end,
+    gleam_erlang_ffi:select(Selector).
+
+-spec process_status_info(self(any(), any())) -> gleam@otp@system:status_info().
+process_status_info(Self) ->
+    {status_info,
+        erlang:binary_to_atom(<<"gleam@otp@actor"/utf8>>),
+        erlang:element(3, Self),
+        erlang:element(2, Self),
+        erlang:element(7, Self),
+        gleam@dynamic:from(erlang:element(4, Self))}.
+
+-spec init_selector(
+    gleam@erlang@process:subject(LYW),
+    gleam@erlang@process:selector(LYW)
+) -> gleam@erlang@process:selector(message(LYW)).
+init_selector(Subject, Selector) ->
+    _pipe = gleam_erlang_ffi:new_selector(),
+    _pipe@1 = gleam@erlang@process:selecting(
+        _pipe,
+        Subject,
+        fun(Field@0) -> {message, Field@0} end
+    ),
+    gleam_erlang_ffi:merge_selector(
+        _pipe@1,
+        gleam_erlang_ffi:map_selector(
+            Selector,
+            fun(Field@0) -> {message, Field@0} end
+        )
+    ).
+
+-spec loop(self(any(), any())) -> gleam@erlang@process:exit_reason().
+loop(Self) ->
+    case receive_message(Self) of
+        {system, System} ->
+            case System of
+                {get_state, Callback} ->
+                    Callback(gleam@dynamic:from(erlang:element(4, Self))),
+                    loop(Self);
+
+                {resume, Callback@1} ->
+                    Callback@1(),
+                    loop(erlang:setelement(2, Self, running));
+
+                {suspend, Callback@2} ->
+                    Callback@2(),
+                    loop(erlang:setelement(2, Self, suspended));
+
+                {get_status, Callback@3} ->
+                    Callback@3(process_status_info(Self)),
+                    loop(Self)
+            end;
+
+        {unexpected, Message} ->
+            logger:warning(
+                unicode:characters_to_list(
+                    <<"Actor discarding unexpected message: ~s"/utf8>>
+                ),
+                [unicode:characters_to_list(gleam@string:inspect(Message))]
+            ),
+            loop(Self);
+
+        {message, Msg} ->
+            case (erlang:element(8, Self))(Msg, erlang:element(4, Self)) of
+                {stop, Reason} ->
+                    exit_process(Reason);
+
+                {continue, State, New_selector} ->
+                    Selector = begin
+                        _pipe = New_selector,
+                        _pipe@1 = gleam@option:map(
+                            _pipe,
+                            fun(_capture) ->
+                                init_selector(erlang:element(5, Self), _capture)
+                            end
+                        ),
+                        gleam@option:unwrap(_pipe@1, erlang:element(6, Self))
+                    end,
+                    loop(
+                        erlang:setelement(
+                            6,
+                            erlang:setelement(4, Self, State),
+                            Selector
+                        )
+                    )
+            end
+    end.
+
+-spec initialise_actor(
+    spec(any(), LUY),
+    gleam@erlang@process:subject({ok, gleam@erlang@process:subject(LUY)} |
+        {error, gleam@erlang@process:exit_reason()})
+) -> gleam@erlang@process:exit_reason().
+initialise_actor(Spec, Ack) ->
+    Subject = gleam@erlang@process:new_subject(),
+    case (erlang:element(2, Spec))() of
+        {ready, State, Selector} ->
+            Selector@1 = init_selector(Subject, Selector),
+            gleam@erlang@process:send(Ack, {ok, Subject}),
+            Self = {self,
+                running,
+                gleam@erlang@process:subject_owner(Ack),
+                State,
+                Subject,
+                Selector@1,
+                sys:debug_options([]),
+                erlang:element(4, Spec)},
+            loop(Self);
+
+        {failed, Reason} ->
+            gleam@erlang@process:send(Ack, {error, {abnormal, Reason}}),
+            exit_process({abnormal, Reason})
+    end.
+
+-spec to_erlang_start_result(
+    {ok, gleam@erlang@process:subject(any())} | {error, start_error()}
+) -> {ok, gleam@erlang@process:pid_()} | {error, gleam@dynamic:dynamic_()}.
+to_erlang_start_result(Res) ->
+    case Res of
+        {ok, X} ->
+            {ok, gleam@erlang@process:subject_owner(X)};
+
+        {error, X@1} ->
+            {error, gleam@dynamic:from(X@1)}
+    end.
+
+-spec start_spec(spec(any(), LVM)) -> {ok, gleam@erlang@process:subject(LVM)} |
+    {error, start_error()}.
+start_spec(Spec) ->
+    Ack_subject = gleam@erlang@process:new_subject(),
+    Child = gleam@erlang@process:start(
+        fun() -> initialise_actor(Spec, Ack_subject) end,
+        true
+    ),
+    Monitor = gleam@erlang@process:monitor_process(Child),
+    Selector = begin
+        _pipe = gleam_erlang_ffi:new_selector(),
+        _pipe@1 = gleam@erlang@process:selecting(
+            _pipe,
+            Ack_subject,
+            fun(Field@0) -> {ack, Field@0} end
+        ),
+        gleam@erlang@process:selecting_process_down(
+            _pipe@1,
+            Monitor,
+            fun(Field@0) -> {mon, Field@0} end
+        )
+    end,
+    Result = case gleam_erlang_ffi:select(Selector, erlang:element(3, Spec)) of
+        {ok, {ack, {ok, Channel}}} ->
+            {ok, Channel};
+
+        {ok, {ack, {error, Reason}}} ->
+            {error, {init_failed, Reason}};
+
+        {ok, {mon, Down}} ->
+            {error, {init_crashed, erlang:element(3, Down)}};
+
+        {error, nil} ->
+            gleam@erlang@process:kill(Child),
+            {error, init_timeout}
+    end,
+    gleam_erlang_ffi:demonitor(Monitor),
+    Result.
+
+-spec start(LVS, fun((LVT, LVS) -> next(LVT, LVS))) -> {ok,
+        gleam@erlang@process:subject(LVT)} |
+    {error, start_error()}.
+start(State, Loop) ->
+    start_spec(
+        {spec,
+            fun() -> {ready, State, gleam_erlang_ffi:new_selector()} end,
+            5000,
+            Loop}
+    ).
+
+-spec send(gleam@erlang@process:subject(LVZ), LVZ) -> nil.
+send(Subject, Msg) ->
+    gleam@erlang@process:send(Subject, Msg).
+
+-spec call(
+    gleam@erlang@process:subject(LWB),
+    fun((gleam@erlang@process:subject(LWD)) -> LWB),
+    integer()
+) -> LWD.
+call(Selector, Make_message, Timeout) ->
+    gleam@erlang@process:call(Selector, Make_message, Timeout).
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@intensity_tracker.cache b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@intensity_tracker.cache
new file mode 100644
index 0000000..2970843
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@intensity_tracker.cache
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@intensity_tracker.cache_meta b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@intensity_tracker.cache_meta
new file mode 100644
index 0000000..1997b5a
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@intensity_tracker.cache_meta
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@intensity_tracker.erl b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@intensity_tracker.erl
new file mode 100644
index 0000000..8792f14
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@intensity_tracker.erl
@@ -0,0 +1,53 @@
+-module(gleam@otp@intensity_tracker).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function]).
+
+-export([new/2, trim_window/3, add_event/1]).
+-export_type([intensity_tracker/0, too_intense/0]).
+
+-opaque intensity_tracker() :: {intensity_tracker,
+        integer(),
+        integer(),
+        list(integer())}.
+
+-type too_intense() :: too_intense.
+
+-spec new(integer(), integer()) -> intensity_tracker().
+new(Limit, Period) ->
+    {intensity_tracker, Limit, Period, []}.
+
+-spec now_seconds() -> integer().
+now_seconds() ->
+    erlang:monotonic_time(1).
+
+-spec trim_window(list(integer()), integer(), integer()) -> list(integer()).
+trim_window(Events, Now, Period) ->
+    case Events of
+        [] ->
+            [];
+
+        [Event | Events@1] ->
+            case Now >= (Event + Period) of
+                true ->
+                    [Event | trim_window(Events@1, Now, Period)];
+
+                false ->
+                    []
+            end
+    end.
+
+-spec add_event(intensity_tracker()) -> {ok, intensity_tracker()} |
+    {error, too_intense()}.
+add_event(Tracker) ->
+    Now = now_seconds(),
+    Events = trim_window(
+        [Now | erlang:element(4, Tracker)],
+        Now,
+        erlang:element(3, Tracker)
+    ),
+    case gleam@list:length(Events) >= erlang:element(2, Tracker) of
+        true ->
+            {error, too_intense};
+
+        false ->
+            {ok, erlang:setelement(4, Tracker, Events)}
+    end.
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@port.cache b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@port.cache
new file mode 100644
index 0000000..e911262
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@port.cache
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@port.cache_meta b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@port.cache_meta
new file mode 100644
index 0000000..5f1cb59
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@port.cache_meta
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@port.erl b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@port.erl
new file mode 100644
index 0000000..b205739
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@port.erl
@@ -0,0 +1,8 @@
+-module(gleam@otp@port).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function]).
+
+-export_type([port_/0]).
+
+-type port_() :: any().
+
+
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@supervisor.cache b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@supervisor.cache
new file mode 100644
index 0000000..e3cbbc7
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@supervisor.cache
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@supervisor.cache_meta b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@supervisor.cache_meta
new file mode 100644
index 0000000..f6f257e
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@supervisor.cache_meta
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@supervisor.erl b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@supervisor.erl
new file mode 100644
index 0000000..75e6c9f
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@supervisor.erl
@@ -0,0 +1,322 @@
+-module(gleam@otp@supervisor).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function]).
+
+-export([add/2, supervisor/1, worker/1, returning/2, start_spec/1, start/1, application_stopped/0, to_erlang_start_result/1]).
+-export_type([spec/2, children/1, child_spec/3, child_start_error/0, message/0, instruction/0, state/1, starter/1, child/1, handle_exit_error/0, application_start_mode/0, application_stop/0]).
+
+-type spec(MID, MIE) :: {spec,
+        MID,
+        integer(),
+        integer(),
+        fun((children(MID)) -> children(MIE))}.
+
+-opaque children(MIF) :: {ready, starter(MIF)} | {failed, child_start_error()}.
+
+-opaque child_spec(MIG, MIH, MII) :: {child_spec,
+        fun((MIH) -> {ok, gleam@erlang@process:subject(MIG)} |
+            {error, gleam@otp@actor:start_error()}),
+        fun((MIH, gleam@erlang@process:subject(MIG)) -> MII)}.
+
+-type child_start_error() :: {child_start_error,
+        gleam@option:option(gleam@erlang@process:pid_()),
+        gleam@otp@actor:start_error()}.
+
+-opaque message() :: {exit, gleam@erlang@process:exit_message()} |
+    {retry_restart, gleam@erlang@process:pid_()}.
+
+-type instruction() :: start_all | {start_from, gleam@erlang@process:pid_()}.
+
+-type state(MIJ) :: {state,
+        gleam@otp@intensity_tracker:intensity_tracker(),
+        starter(MIJ),
+        gleam@erlang@process:subject(gleam@erlang@process:pid_())}.
+
+-type starter(MIK) :: {starter,
+        MIK,
+        gleam@option:option(fun((instruction()) -> {ok,
+                {starter(MIK), instruction()}} |
+            {error, child_start_error()}))}.
+
+-type child(MIL) :: {child, gleam@erlang@process:pid_(), MIL}.
+
+-type handle_exit_error() :: {restart_failed,
+        gleam@erlang@process:pid_(),
+        gleam@otp@intensity_tracker:intensity_tracker()} |
+    too_many_restarts.
+
+-type application_start_mode() :: normal |
+    {takeover, gleam@erlang@node:node_()} |
+    {failover, gleam@erlang@node:node_()}.
+
+-type application_stop() :: any().
+
+-spec start_child(child_spec(any(), MIP, MIQ), MIP) -> {ok, child(MIQ)} |
+    {error, child_start_error()}.
+start_child(Child_spec, Argument) ->
+    gleam@result:then(
+        begin
+            _pipe = (erlang:element(2, Child_spec))(Argument),
+            gleam@result:map_error(
+                _pipe,
+                fun(_capture) -> {child_start_error, none, _capture} end
+            )
+        end,
+        fun(Subject) ->
+            {ok,
+                {child,
+                    gleam@erlang@process:subject_owner(Subject),
+                    (erlang:element(3, Child_spec))(Argument, Subject)}}
+        end
+    ).
+
+-spec shutdown_child(
+    gleam@erlang@process:pid_(),
+    child_spec(any(), any(), any())
+) -> nil.
+shutdown_child(Pid, _) ->
+    gleam@erlang@process:send_exit(Pid).
+
+-spec perform_instruction_for_child(
+    MJD,
+    instruction(),
+    child_spec(any(), MJD, MJF),
+    child(MJF)
+) -> {ok, {child(MJF), instruction()}} | {error, child_start_error()}.
+perform_instruction_for_child(Argument, Instruction, Child_spec, Child) ->
+    Current = erlang:element(2, Child),
+    case Instruction of
+        {start_from, Target} when Target =/= Current ->
+            {ok, {Child, Instruction}};
+
+        _ ->
+            shutdown_child(Current, Child_spec),
+            gleam@result:then(
+                start_child(Child_spec, Argument),
+                fun(Child@1) -> {ok, {Child@1, start_all}} end
+            )
+    end.
+
+-spec add_child_to_starter(
+    starter(MJN),
+    child_spec(any(), MJN, MJQ),
+    child(MJQ)
+) -> starter(MJQ).
+add_child_to_starter(Starter, Child_spec, Child) ->
+    Starter@3 = fun(Instruction) ->
+        gleam@result:then(case erlang:element(3, Starter) of
+                {some, Start} ->
+                    Start(Instruction);
+
+                none ->
+                    {ok, {Starter, Instruction}}
+            end, fun(_use0) ->
+                {Starter@1, Instruction@1} = _use0,
+                gleam@result:then(
+                    perform_instruction_for_child(
+                        erlang:element(2, Starter@1),
+                        Instruction@1,
+                        Child_spec,
+                        Child
+                    ),
+                    fun(_use0@1) ->
+                        {Child@1, Instruction@2} = _use0@1,
+                        Starter@2 = add_child_to_starter(
+                            Starter@1,
+                            Child_spec,
+                            Child@1
+                        ),
+                        {ok, {Starter@2, Instruction@2}}
+                    end
+                )
+            end)
+    end,
+    {starter, erlang:element(3, Child), {some, Starter@3}}.
+
+-spec start_and_add_child(starter(MJW), child_spec(any(), MJW, MJZ)) -> children(MJZ).
+start_and_add_child(State, Child_spec) ->
+    case start_child(Child_spec, erlang:element(2, State)) of
+        {ok, Child} ->
+            {ready, add_child_to_starter(State, Child_spec, Child)};
+
+        {error, Reason} ->
+            {failed, Reason}
+    end.
+
+-spec add(children(MKE), child_spec(any(), MKE, MKH)) -> children(MKH).
+add(Children, Child_spec) ->
+    case Children of
+        {failed, Fail} ->
+            {failed, Fail};
+
+        {ready, State} ->
+            start_and_add_child(State, Child_spec)
+    end.
+
+-spec supervisor(
+    fun((MKM) -> {ok, gleam@erlang@process:subject(MKN)} |
+        {error, gleam@otp@actor:start_error()})
+) -> child_spec(MKN, MKM, MKM).
+supervisor(Start) ->
+    {child_spec, Start, fun(Argument, _) -> Argument end}.
+
+-spec worker(
+    fun((MKU) -> {ok, gleam@erlang@process:subject(MKV)} |
+        {error, gleam@otp@actor:start_error()})
+) -> child_spec(MKV, MKU, MKU).
+worker(Start) ->
+    {child_spec, Start, fun(Argument, _) -> Argument end}.
+
+-spec returning(
+    child_spec(MLC, MLD, any()),
+    fun((MLD, gleam@erlang@process:subject(MLC)) -> MLJ)
+) -> child_spec(MLC, MLD, MLJ).
+returning(Child, Updater) ->
+    {child_spec, erlang:element(2, Child), Updater}.
+
+-spec init(spec(any(), MLO)) -> gleam@otp@actor:init_result(state(MLO), message()).
+init(Spec) ->
+    Retry = gleam@erlang@process:new_subject(),
+    gleam_erlang_ffi:trap_exits(true),
+    Selector = begin
+        _pipe = gleam_erlang_ffi:new_selector(),
+        _pipe@1 = gleam@erlang@process:selecting(
+            _pipe,
+            Retry,
+            fun(Field@0) -> {retry_restart, Field@0} end
+        ),
+        gleam@erlang@process:selecting_trapped_exits(
+            _pipe@1,
+            fun(Field@0) -> {exit, Field@0} end
+        )
+    end,
+    Result = begin
+        _pipe@2 = {starter, erlang:element(2, Spec), none},
+        _pipe@3 = {ready, _pipe@2},
+        (erlang:element(5, Spec))(_pipe@3)
+    end,
+    case Result of
+        {ready, Starter} ->
+            Restarts = gleam@otp@intensity_tracker:new(
+                erlang:element(3, Spec),
+                erlang:element(4, Spec)
+            ),
+            State = {state, Restarts, Starter, Retry},
+            {ready, State, Selector};
+
+        {failed, Error} ->
+            {failed, case erlang:element(3, Error) of
+                    init_timeout ->
+                        <<"Child initialisation timed out"/utf8>>;
+
+                    {init_crashed, Reason} ->
+                        gleam@string:append(
+                            <<"Child crashed during initialisation: "/utf8>>,
+                            gleam@string:inspect(Reason)
+                        );
+
+                    {init_failed, Reason@1} ->
+                        gleam@string:append(
+                            <<"Child failed to start during initialisation: "/utf8>>,
+                            gleam@string:inspect(Reason@1)
+                        )
+                end}
+    end.
+
+-spec handle_exit(gleam@erlang@process:pid_(), state(MLU)) -> gleam@otp@actor:next(message(), state(MLU)).
+handle_exit(Pid, State) ->
+    Outcome = begin
+        _assert_subject = erlang:element(3, erlang:element(3, State)),
+        {some, Start} = case _assert_subject of
+            {some, _} -> _assert_subject;
+            _assert_fail ->
+                erlang:error(#{gleam_error => let_assert,
+                            message => <<"Assertion pattern match failed"/utf8>>,
+                            value => _assert_fail,
+                            module => <<"gleam/otp/supervisor"/utf8>>,
+                            function => <<"handle_exit"/utf8>>,
+                            line => 293})
+        end,
+        gleam@result:then(
+            begin
+                _pipe = erlang:element(2, State),
+                _pipe@1 = gleam@otp@intensity_tracker:add_event(_pipe),
+                gleam@result:map_error(_pipe@1, fun(_) -> too_many_restarts end)
+            end,
+            fun(Restarts) ->
+                gleam@result:then(
+                    begin
+                        _pipe@2 = Start({start_from, Pid}),
+                        gleam@result:map_error(
+                            _pipe@2,
+                            fun(E) ->
+                                {restart_failed,
+                                    gleam@option:unwrap(
+                                        erlang:element(2, E),
+                                        Pid
+                                    ),
+                                    Restarts}
+                            end
+                        )
+                    end,
+                    fun(_use0) ->
+                        {Starter, _} = _use0,
+                        {ok,
+                            erlang:setelement(
+                                2,
+                                erlang:setelement(3, State, Starter),
+                                Restarts
+                            )}
+                    end
+                )
+            end
+        )
+    end,
+    case Outcome of
+        {ok, State@1} ->
+            gleam@otp@actor:continue(State@1);
+
+        {error, {restart_failed, Failed_child, Restarts@1}} ->
+            gleam@erlang@process:send(erlang:element(4, State), Failed_child),
+            State@2 = erlang:setelement(2, State, Restarts@1),
+            gleam@otp@actor:continue(State@2);
+
+        {error, too_many_restarts} ->
+            {stop,
+                {abnormal,
+                    <<"Child processes restarted too many times within allowed period"/utf8>>}}
+    end.
+
+-spec loop(message(), state(MLZ)) -> gleam@otp@actor:next(message(), state(MLZ)).
+loop(Message, State) ->
+    case Message of
+        {exit, Exit_message} ->
+            handle_exit(erlang:element(2, Exit_message), State);
+
+        {retry_restart, Pid} ->
+            handle_exit(Pid, State)
+    end.
+
+-spec start_spec(spec(any(), any())) -> {ok,
+        gleam@erlang@process:subject(message())} |
+    {error, gleam@otp@actor:start_error()}.
+start_spec(Spec) ->
+    gleam@otp@actor:start_spec(
+        {spec, fun() -> init(Spec) end, 60000, fun loop/2}
+    ).
+
+-spec start(fun((children(nil)) -> children(any()))) -> {ok,
+        gleam@erlang@process:subject(message())} |
+    {error, gleam@otp@actor:start_error()}.
+start(Init) ->
+    start_spec({spec, nil, 1, 5, Init}).
+
+-spec application_stopped() -> application_stop().
+application_stopped() ->
+    gleam_otp_external:application_stopped().
+
+-spec to_erlang_start_result(
+    {ok, gleam@erlang@process:subject(any())} |
+        {error, gleam@otp@actor:start_error()}
+) -> {ok, gleam@erlang@process:pid_()} | {error, gleam@dynamic:dynamic_()}.
+to_erlang_start_result(Res) ->
+    gleam@otp@actor:to_erlang_start_result(Res).
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@system.cache b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@system.cache
new file mode 100644
index 0000000..1ecd94e
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@system.cache
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@system.cache_meta b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@system.cache_meta
new file mode 100644
index 0000000..9f64041
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@system.cache_meta
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@system.erl b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@system.erl
new file mode 100644
index 0000000..622e5ea
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@system.erl
@@ -0,0 +1,43 @@
+-module(gleam@otp@system).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function]).
+
+-export([debug_state/1, get_state/1, suspend/1, resume/1]).
+-export_type([mode/0, debug_option/0, debug_state/0, status_info/0, system_message/0, do_not_leak/0]).
+
+-type mode() :: running | suspended.
+
+-type debug_option() :: no_debug.
+
+-type debug_state() :: any().
+
+-type status_info() :: {status_info,
+        gleam@erlang@atom:atom_(),
+        gleam@erlang@process:pid_(),
+        mode(),
+        debug_state(),
+        gleam@dynamic:dynamic_()}.
+
+-type system_message() :: {resume, fun(() -> nil)} |
+    {suspend, fun(() -> nil)} |
+    {get_state, fun((gleam@dynamic:dynamic_()) -> nil)} |
+    {get_status, fun((status_info()) -> nil)}.
+
+-type do_not_leak() :: any().
+
+-spec debug_state(list(debug_option())) -> debug_state().
+debug_state(A) ->
+    sys:debug_options(A).
+
+-spec get_state(gleam@erlang@process:pid_()) -> gleam@dynamic:dynamic_().
+get_state(From) ->
+    sys:get_state(From).
+
+-spec suspend(gleam@erlang@process:pid_()) -> nil.
+suspend(Pid) ->
+    sys:suspend(Pid),
+    nil.
+
+-spec resume(gleam@erlang@process:pid_()) -> nil.
+resume(Pid) ->
+    sys:resume(Pid),
+    nil.
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@task.cache b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@task.cache
new file mode 100644
index 0000000..3360869
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@task.cache
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@task.cache_meta b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@task.cache_meta
new file mode 100644
index 0000000..e4f89cf
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@task.cache_meta
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@task.erl b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@task.erl
new file mode 100644
index 0000000..ae4037d
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam@otp@task.erl
@@ -0,0 +1,111 @@
+-module(gleam@otp@task).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function]).
+
+-export([async/1, try_await/2, await/2, try_await_forever/1, await_forever/1]).
+-export_type([task/1, await_error/0, message/1]).
+
+-opaque task(MEB) :: {task,
+        gleam@erlang@process:pid_(),
+        gleam@erlang@process:pid_(),
+        gleam@erlang@process:process_monitor(),
+        gleam@erlang@process:selector(message(MEB))}.
+
+-type await_error() :: timeout | {exit, gleam@dynamic:dynamic_()}.
+
+-type message(MEC) :: {from_monitor, gleam@erlang@process:process_down()} |
+    {from_subject, MEC}.
+
+-spec async(fun(() -> MED)) -> task(MED).
+async(Work) ->
+    Owner = erlang:self(),
+    Subject = gleam@erlang@process:new_subject(),
+    Pid = gleam@erlang@process:start(
+        fun() -> gleam@erlang@process:send(Subject, Work()) end,
+        true
+    ),
+    Monitor = gleam@erlang@process:monitor_process(Pid),
+    Selector = begin
+        _pipe = gleam_erlang_ffi:new_selector(),
+        _pipe@1 = gleam@erlang@process:selecting_process_down(
+            _pipe,
+            Monitor,
+            fun(Field@0) -> {from_monitor, Field@0} end
+        ),
+        gleam@erlang@process:selecting(
+            _pipe@1,
+            Subject,
+            fun(Field@0) -> {from_subject, Field@0} end
+        )
+    end,
+    {task, Owner, Pid, Monitor, Selector}.
+
+-spec assert_owner(task(any())) -> nil.
+assert_owner(Task) ->
+    Self = erlang:self(),
+    case erlang:element(2, Task) =:= Self of
+        true ->
+            nil;
+
+        false ->
+            gleam@erlang@process:send_abnormal_exit(
+                Self,
+                <<"awaited on a task that does not belong to this process"/utf8>>
+            )
+    end.
+
+-spec try_await(task(MEH), integer()) -> {ok, MEH} | {error, await_error()}.
+try_await(Task, Timeout) ->
+    assert_owner(Task),
+    case gleam_erlang_ffi:select(erlang:element(5, Task), Timeout) of
+        {ok, {from_subject, X}} ->
+            gleam_erlang_ffi:demonitor(erlang:element(4, Task)),
+            {ok, X};
+
+        {ok, {from_monitor, {process_down, _, Reason}}} ->
+            {error, {exit, Reason}};
+
+        {error, nil} ->
+            {error, timeout}
+    end.
+
+-spec await(task(MEL), integer()) -> MEL.
+await(Task, Timeout) ->
+    _assert_subject = try_await(Task, Timeout),
+    {ok, Value} = case _assert_subject of
+        {ok, _} -> _assert_subject;
+        _assert_fail ->
+            erlang:error(#{gleam_error => let_assert,
+                        message => <<"Assertion pattern match failed"/utf8>>,
+                        value => _assert_fail,
+                        module => <<"gleam/otp/task"/utf8>>,
+                        function => <<"await"/utf8>>,
+                        line => 117})
+    end,
+    Value.
+
+-spec try_await_forever(task(MEN)) -> {ok, MEN} | {error, await_error()}.
+try_await_forever(Task) ->
+    assert_owner(Task),
+    case gleam_erlang_ffi:select(erlang:element(5, Task)) of
+        {from_subject, X} ->
+            gleam_erlang_ffi:demonitor(erlang:element(4, Task)),
+            {ok, X};
+
+        {from_monitor, {process_down, _, Reason}} ->
+            {error, {exit, Reason}}
+    end.
+
+-spec await_forever(task(MER)) -> MER.
+await_forever(Task) ->
+    _assert_subject = try_await_forever(Task),
+    {ok, Value} = case _assert_subject of
+        {ok, _} -> _assert_subject;
+        _assert_fail ->
+            erlang:error(#{gleam_error => let_assert,
+                        message => <<"Assertion pattern match failed"/utf8>>,
+                        value => _assert_fail,
+                        module => <<"gleam/otp/task"/utf8>>,
+                        function => <<"await_forever"/utf8>>,
+                        line => 149})
+    end,
+    Value.
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam_otp.cache b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam_otp.cache
new file mode 100644
index 0000000..601b922
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam_otp.cache
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam_otp.cache_meta b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam_otp.cache_meta
new file mode 100644
index 0000000..6b7a3a8
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam_otp.cache_meta
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam_otp.erl b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam_otp.erl
new file mode 100644
index 0000000..9381ad2
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam_otp.erl
@@ -0,0 +1,28 @@
+-module(gleam_otp).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function]).
+
+-export([main/0]).
+
+-spec spawn_task(integer()) -> gleam@otp@task:task(nil).
+spawn_task(I) ->
+    gleam@otp@task:async(fun() -> case (I rem 500) =:= 0 of
+                true ->
+                    gleam@io:println(
+                        <<"Hello from "/utf8, (gleam@int:to_string(I))/binary>>
+                    );
+
+                false ->
+                    nil
+            end end).
+
+-spec main() -> integer().
+main() ->
+    gleam@io:debug(
+        gleam_otp_test_external:get_message_queue_length(erlang:self())
+    ),
+    _pipe = gleam@list:range(0, 1000000),
+    _pipe@1 = gleam@list:map(_pipe, fun spawn_task/1),
+    gleam@list:each(_pipe@1, fun gleam@otp@task:await_forever/1),
+    gleam@io:debug(
+        gleam_otp_test_external:get_message_queue_length(erlang:self())
+    ).
diff --git a/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam_otp_external.erl b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam_otp_external.erl
new file mode 100644
index 0000000..8910a67
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/_gleam_artefacts/gleam_otp_external.erl
@@ -0,0 +1,43 @@
+-module(gleam_otp_external).
+
+-export([application_stopped/0, convert_system_message/2]).
+
+% TODO: support other system messages
+%   {replace_state, StateFn}
+%   {change_code, Mod, Vsn, Extra}
+%   {terminate, Reason}
+%   {debug, {log, Flag}}
+%   {debug, {trace, Flag}}
+%   {debug, {log_to_file, FileName}}
+%   {debug, {statistics, Flag}}
+%   {debug, no_debug}
+%   {debug, {install, {Func, FuncState}}}
+%   {debug, {install, {FuncId, Func, FuncState}}}
+%   {debug, {remove, FuncOrId}}
+%   GetStatus(Subject(StatusInfo))
+convert_system_message({From, Ref}, Request) when is_pid(From) ->
+    Reply = fun(Msg) ->
+        erlang:send(From, {Ref, Msg}),
+        nil
+    end,
+    System = fun(Callback) ->
+        {system, {Request, Callback}}
+    end,
+    case Request of
+        get_status -> System(fun(Status) -> Reply(process_status(Status)) end);
+        get_state -> System(Reply);
+        suspend -> System(fun() -> Reply(ok) end);
+        resume -> System(fun() -> Reply(ok) end);
+        Other -> {unexpeceted, Other}
+    end.
+
+process_status({status_info, Module, Parent, Mode, DebugState, State}) ->
+    Data = [
+        get(), Mode, Parent, DebugState,
+        [{header, "Status for Gleam process " ++ pid_to_list(self())},
+         {data, [{'Status', Mode}, {'Parent', Parent}, {'State', State}]}]
+    ],
+    {status, self(), {module, Module}, Data}.
+
+application_stopped() ->
+    ok.
diff --git a/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@actor.beam b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@actor.beam
new file mode 100644
index 0000000..1a777b4
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@actor.beam
diff --git a/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@intensity_tracker.beam b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@intensity_tracker.beam
new file mode 100644
index 0000000..5a126b5
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@intensity_tracker.beam
diff --git a/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@port.beam b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@port.beam
new file mode 100644
index 0000000..8b72b7d
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@port.beam
diff --git a/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@supervisor.beam b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@supervisor.beam
new file mode 100644
index 0000000..72f4b32
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@supervisor.beam
diff --git a/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@system.beam b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@system.beam
new file mode 100644
index 0000000..3aefd21
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@system.beam
diff --git a/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@task.beam b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@task.beam
new file mode 100644
index 0000000..c21bc3b
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam@otp@task.beam
diff --git a/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam_otp.app b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam_otp.app
new file mode 100644
index 0000000..21dd444
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam_otp.app
@@ -0,0 +1,8 @@
+{application, gleam_otp, [
+    {vsn, "0.8.0"},
+    {applications, [gleam_erlang,
+                    gleam_stdlib]},
+    {description, "Fault tolerant multicore Gleam programs with OTP"},
+    {modules, []},
+    {registered, []}
+]}.
diff --git a/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam_otp.beam b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam_otp.beam
new file mode 100644
index 0000000..0a25445
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam_otp.beam
diff --git a/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam_otp_external.beam b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam_otp_external.beam
new file mode 100644
index 0000000..f77f93b
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/ebin/gleam_otp_external.beam
diff --git a/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@actor_Continue.hrl b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@actor_Continue.hrl
new file mode 100644
index 0000000..85677d1
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@actor_Continue.hrl
@@ -0,0 +1,4 @@
+-record(continue, {
+    state :: any(),
+    selector :: gleam@option:option(gleam@erlang@process:selector(any()))
+}).
diff --git a/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@actor_Ready.hrl b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@actor_Ready.hrl
new file mode 100644
index 0000000..75faa95
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@actor_Ready.hrl
@@ -0,0 +1 @@
+-record(ready, {state :: any(), selector :: gleam@erlang@process:selector(any())}).
diff --git a/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@actor_Spec.hrl b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@actor_Spec.hrl
new file mode 100644
index 0000000..5287439
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@actor_Spec.hrl
@@ -0,0 +1,5 @@
+-record(spec, {
+    init :: fun(() -> gleam@otp@actor:init_result(any(), any())),
+    init_timeout :: integer(),
+    loop :: fun((any(), any()) -> gleam@otp@actor:next(any(), any()))
+}).
diff --git a/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@intensity_tracker_IntensityTracker.hrl b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@intensity_tracker_IntensityTracker.hrl
new file mode 100644
index 0000000..3ed0b01
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@intensity_tracker_IntensityTracker.hrl
@@ -0,0 +1,5 @@
+-record(intensity_tracker, {
+    limit :: integer(),
+    period :: integer(),
+    events :: list(integer())
+}).
diff --git a/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@supervisor_ChildSpec.hrl b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@supervisor_ChildSpec.hrl
new file mode 100644
index 0000000..7afd07f
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@supervisor_ChildSpec.hrl
@@ -0,0 +1,5 @@
+-record(child_spec, {
+    start :: fun((any()) -> {ok, gleam@erlang@process:subject(any())} |
+        {error, gleam@otp@actor:start_error()}),
+    returning :: fun((any(), gleam@erlang@process:subject(any())) -> any())
+}).
diff --git a/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@supervisor_Spec.hrl b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@supervisor_Spec.hrl
new file mode 100644
index 0000000..b10bd9f
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@supervisor_Spec.hrl
@@ -0,0 +1,6 @@
+-record(spec, {
+    argument :: any(),
+    max_frequency :: integer(),
+    frequency_period :: integer(),
+    init :: fun((gleam@otp@supervisor:children(any())) -> gleam@otp@supervisor:children(any()))
+}).
diff --git a/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@system_StatusInfo.hrl b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@system_StatusInfo.hrl
new file mode 100644
index 0000000..99ab4cb
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@system_StatusInfo.hrl
@@ -0,0 +1,7 @@
+-record(status_info, {
+    module :: gleam@erlang@atom:atom_(),
+    parent :: gleam@erlang@process:pid_(),
+    mode :: gleam@otp@system:mode(),
+    debug_state :: gleam@otp@system:debug_state(),
+    state :: gleam@dynamic:dynamic_()
+}).
diff --git a/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@task_Exit.hrl b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@task_Exit.hrl
new file mode 100644
index 0000000..7c83874
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@task_Exit.hrl
@@ -0,0 +1 @@
+-record(exit, {reason :: gleam@dynamic:dynamic_()}).
diff --git a/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@task_Task.hrl b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@task_Task.hrl
new file mode 100644
index 0000000..959bea8
--- /dev/null
+++ b/aoc2023/build/dev/erlang/gleam_otp/include/gleam@otp@task_Task.hrl
@@ -0,0 +1,6 @@
+-record(task, {
+    owner :: gleam@erlang@process:pid_(),
+    pid :: gleam@erlang@process:pid_(),
+    monitor :: gleam@erlang@process:process_monitor(),
+    selector :: gleam@erlang@process:selector(gleam@otp@task:message(any()))
+}).