<!-- livebook:{"persist_outputs":true} -->

# Day 24

## Section

```elixir
defmodule Day24 do
  def parse("inp " <> reg), do: {:inp, String.to_atom(reg)}

  def parse(<<op::binary-size(3)>> <> " " <> <<reg>> <> " " <> arg) do
    {String.to_atom(op), String.to_atom(<<reg>>), parse_arg(arg)}
  end

  defp parse_arg(arg) do
    case Integer.parse(arg) do
      {num, ""} -> num
      :error -> String.to_atom(arg)
    end
  end

  def evaluate(ops, input), do: evaluate(ops, to_digits(input), %{w: 0, x: 0, y: 0, z: 0})

  defp evaluate([], _, regs), do: regs

  defp evaluate([{:inp, reg} | rest], [v | input], regs),
    do: evaluate(rest, input, %{regs | reg => v})

  defp evaluate([{:eql, reg, v} | rest], input, regs) do
    val = if get(reg, regs) == get(v, regs), do: 1, else: 0

    evaluate(rest, input, %{regs | reg => val})
  end

  defp evaluate([{:add, reg, v} | rest], input, regs),
    do: evaluate(rest, input, %{regs | reg => get(reg, regs) + get(v, regs)})

  defp evaluate([{:mul, reg, v} | rest], input, regs),
    do: evaluate(rest, input, %{regs | reg => get(reg, regs) * get(v, regs)})

  defp evaluate([{:div, reg, v} | rest], input, regs),
    do: evaluate(rest, input, %{regs | reg => div(get(reg, regs), get(v, regs))})

  defp evaluate([{:mod, reg, v} | rest], input, regs),
    do: evaluate(rest, input, %{regs | reg => rem(get(reg, regs), get(v, regs))})

  defp get(imm, _regs) when is_integer(imm), do: imm
  defp get(reg, regs) when is_atom(reg), do: Map.get(regs, reg, 0)

  defp to_digits(int) when is_integer(int), do: Integer.digits(int)
  defp to_digits(digits) when is_list(digits), do: digits
end

input =
  File.stream!("#{__DIR__}/day24.txt")
  |> Stream.map(&String.trim/1)
  |> Enum.map(&Day24.parse/1)
  |> IO.inspect(limit: :infinity)

length(input)
```

<!-- livebook:{"output":true} -->

```
[
  {:inp, :w},
  {:mul, :x, 0},
  {:add, :x, :z},
  {:mod, :x, 26},
  {:div, :z, 1},
  {:add, :x, 11},
  {:eql, :x, :w},
  {:eql, :x, 0},
  {:mul, :y, 0},
  {:add, :y, 25},
  {:mul, :y, :x},
  {:add, :y, 1},
  {:mul, :z, :y},
  {:mul, :y, 0},
  {:add, :y, :w},
  {:add, :y, 16},
  {:mul, :y, :x},
  {:add, :z, :y},
  {:inp, :w},
  {:mul, :x, 0},
  {:add, :x, :z},
  {:mod, :x, 26},
  {:div, :z, 1},
  {:add, :x, 12},
  {:eql, :x, :w},
  {:eql, :x, 0},
  {:mul, :y, 0},
  {:add, :y, 25},
  {:mul, :y, :x},
  {:add, :y, 1},
  {:mul, :z, :y},
  {:mul, :y, 0},
  {:add, :y, :w},
  {:add, :y, 11},
  {:mul, :y, :x},
  {:add, :z, :y},
  {:inp, :w},
  {:mul, :x, 0},
  {:add, :x, :z},
  {:mod, :x, 26},
  {:div, :z, 1},
  {:add, :x, 13},
  {:eql, :x, :w},
  {:eql, :x, 0},
  {:mul, :y, 0},
  {:add, :y, 25},
  {:mul, :y, :x},
  {:add, :y, 1},
  {:mul, :z, :y},
  {:mul, :y, 0},
  {:add, :y, :w},
  {:add, :y, 12},
  {:mul, :y, :x},
  {:add, :z, :y},
  {:inp, :w},
  {:mul, :x, 0},
  {:add, :x, :z},
  {:mod, :x, 26},
  {:div, :z, 26},
  {:add, :x, -5},
  {:eql, :x, :w},
  {:eql, :x, 0},
  {:mul, :y, 0},
  {:add, :y, 25},
  {:mul, :y, :x},
  {:add, :y, 1},
  {:mul, :z, :y},
  {:mul, :y, 0},
  {:add, :y, :w},
  {:add, :y, 12},
  {:mul, :y, :x},
  {:add, :z, :y},
  {:inp, :w},
  {:mul, :x, 0},
  {:add, :x, :z},
  {:mod, :x, 26},
  {:div, :z, 26},
  {:add, :x, -3},
  {:eql, :x, :w},
  {:eql, :x, 0},
  {:mul, :y, 0},
  {:add, :y, 25},
  {:mul, :y, :x},
  {:add, :y, 1},
  {:mul, :z, :y},
  {:mul, :y, 0},
  {:add, :y, :w},
  {:add, :y, 12},
  {:mul, :y, :x},
  {:add, :z, :y},
  {:inp, :w},
  {:mul, :x, 0},
  {:add, :x, :z},
  {:mod, :x, 26},
  {:div, :z, 1},
  {:add, :x, 14},
  {:eql, :x, :w},
  {:eql, :x, 0},
  {:mul, :y, 0},
  {:add, :y, 25},
  {:mul, :y, :x},
  {:add, :y, 1},
  {:mul, :z, :y},
  {:mul, :y, 0},
  {:add, :y, :w},
  {:add, :y, 2},
  {:mul, :y, :x},
  {:add, :z, :y},
  {:inp, :w},
  {:mul, :x, 0},
  {:add, :x, :z},
  {:mod, :x, 26},
  {:div, :z, 1},
  {:add, :x, 15},
  {:eql, :x, :w},
  {:eql, :x, 0},
  {:mul, :y, 0},
  {:add, :y, 25},
  {:mul, :y, :x},
  {:add, :y, 1},
  {:mul, :z, :y},
  {:mul, :y, 0},
  {:add, :y, :w},
  {:add, :y, 11},
  {:mul, :y, :x},
  {:add, :z, :y},
  {:inp, :w},
  {:mul, :x, 0},
  {:add, :x, :z},
  {:mod, :x, 26},
  {:div, :z, 26},
  {:add, :x, -16},
  {:eql, :x, :w},
  {:eql, :x, 0},
  {:mul, :y, 0},
  {:add, :y, 25},
  {:mul, :y, :x},
  {:add, :y, 1},
  {:mul, :z, :y},
  {:mul, :y, 0},
  {:add, :y, :w},
  {:add, :y, 4},
  {:mul, :y, :x},
  {:add, :z, :y},
  {:inp, :w},
  {:mul, :x, 0},
  {:add, :x, :z},
  {:mod, :x, 26},
  {:div, :z, 1},
  {:add, :x, 14},
  {:eql, :x, :w},
  {:eql, :x, 0},
  {:mul, :y, 0},
  {:add, :y, 25},
  {:mul, :y, :x},
  {:add, :y, 1},
  {:mul, :z, :y},
  {:mul, :y, 0},
  {:add, :y, :w},
  {:add, :y, 12},
  {:mul, :y, :x},
  {:add, :z, :y},
  {:inp, :w},
  {:mul, :x, 0},
  {:add, :x, :z},
  {:mod, :x, 26},
  {:div, :z, 1},
  {:add, :x, 15},
  {:eql, :x, :w},
  {:eql, :x, 0},
  {:mul, :y, 0},
  {:add, :y, 25},
  {:mul, :y, :x},
  {:add, :y, 1},
  {:mul, :z, :y},
  {:mul, :y, 0},
  {:add, :y, :w},
  {:add, :y, 9},
  {:mul, :y, :x},
  {:add, :z, :y},
  {:inp, :w},
  {:mul, :x, 0},
  {:add, :x, :z},
  {:mod, :x, 26},
  {:div, :z, 26},
  {:add, :x, -7},
  {:eql, :x, :w},
  {:eql, :x, 0},
  {:mul, :y, 0},
  {:add, :y, 25},
  {:mul, :y, :x},
  {:add, :y, 1},
  {:mul, :z, :y},
  {:mul, :y, 0},
  {:add, :y, :w},
  {:add, :y, 10},
  {:mul, :y, :x},
  {:add, :z, :y},
  {:inp, :w},
  {:mul, :x, 0},
  {:add, :x, :z},
  {:mod, :x, 26},
  {:div, :z, 26},
  {:add, :x, -11},
  {:eql, :x, :w},
  {:eql, :x, 0},
  {:mul, :y, 0},
  {:add, :y, 25},
  {:mul, :y, :x},
  {:add, :y, 1},
  {:mul, :z, :y},
  {:mul, :y, 0},
  {:add, :y, :w},
  {:add, :y, 11},
  {:mul, :y, :x},
  {:add, :z, :y},
  {:inp, :w},
  {:mul, :x, 0},
  {:add, :x, :z},
  {:mod, :x, 26},
  {:div, :z, 26},
  {:add, :x, -6},
  {:eql, :x, :w},
  {:eql, :x, 0},
  {:mul, :y, 0},
  {:add, :y, 25},
  {:mul, :y, :x},
  {:add, :y, 1},
  {:mul, :z, :y},
  {:mul, :y, 0},
  {:add, :y, :w},
  {:add, :y, 6},
  {:mul, :y, :x},
  {:add, :z, :y},
  {:inp, :w},
  {:mul, :x, 0},
  {:add, :x, :z},
  {:mod, :x, 26},
  {:div, :z, 26},
  {:add, :x, -11},
  {:eql, :x, :w},
  {:eql, :x, 0},
  {:mul, :y, 0},
  {:add, :y, 25},
  {:mul, :y, :x},
  {:add, :y, 1},
  {:mul, :z, :y},
  {:mul, :y, 0},
  {:add, :y, :w},
  {:add, :y, 15},
  {:mul, :y, :x},
  {:add, :z, :y}
]
```

<!-- livebook:{"output":true} -->

```
252
```

```elixir
digits =
  Enum.chunk_while(
  input,
  [],
  fn
    {:inp, _} = inp, [] -> {:cont, [inp]}
    {:inp, _} = inp, acc -> {:cont, Enum.reverse(acc), [inp]}
    other, acc -> {:cont, [other | acc]}
  end,
  fn acc -> {:cont, Enum.reverse(acc), []} end
)
```

<!-- livebook:{"output":true} -->

```
[
  [
    {:inp, :w},
    {:mul, :x, 0},
    {:add, :x, :z},
    {:mod, :x, 26},
    {:div, :z, 1},
    {:add, :x, 11},
    {:eql, :x, :w},
    {:eql, :x, 0},
    {:mul, :y, 0},
    {:add, :y, 25},
    {:mul, :y, :x},
    {:add, :y, 1},
    {:mul, :z, :y},
    {:mul, :y, 0},
    {:add, :y, :w},
    {:add, :y, 16},
    {:mul, :y, :x},
    {:add, :z, :y}
  ],
  [
    {:inp, :w},
    {:mul, :x, 0},
    {:add, :x, :z},
    {:mod, :x, 26},
    {:div, :z, 1},
    {:add, :x, 12},
    {:eql, :x, :w},
    {:eql, :x, 0},
    {:mul, :y, 0},
    {:add, :y, 25},
    {:mul, :y, :x},
    {:add, :y, 1},
    {:mul, :z, :y},
    {:mul, :y, 0},
    {:add, :y, :w},
    {:add, :y, 11},
    {:mul, :y, :x},
    {:add, :z, :y}
  ],
  [
    {:inp, :w},
    {:mul, :x, 0},
    {:add, :x, :z},
    {:mod, :x, 26},
    {:div, :z, 1},
    {:add, :x, 13},
    {:eql, :x, :w},
    {:eql, :x, 0},
    {:mul, :y, 0},
    {:add, :y, 25},
    {:mul, :y, :x},
    {:add, :y, 1},
    {:mul, :z, :y},
    {:mul, :y, 0},
    {:add, :y, :w},
    {:add, :y, 12},
    {:mul, :y, :x},
    {:add, :z, :y}
  ],
  [
    {:inp, :w},
    {:mul, :x, 0},
    {:add, :x, :z},
    {:mod, :x, 26},
    {:div, :z, 26},
    {:add, :x, -5},
    {:eql, :x, :w},
    {:eql, :x, 0},
    {:mul, :y, 0},
    {:add, :y, 25},
    {:mul, :y, :x},
    {:add, :y, 1},
    {:mul, :z, :y},
    {:mul, :y, 0},
    {:add, :y, :w},
    {:add, :y, 12},
    {:mul, :y, :x},
    {:add, :z, :y}
  ],
  [
    {:inp, :w},
    {:mul, :x, 0},
    {:add, :x, :z},
    {:mod, :x, 26},
    {:div, :z, 26},
    {:add, :x, -3},
    {:eql, :x, :w},
    {:eql, :x, 0},
    {:mul, :y, 0},
    {:add, :y, 25},
    {:mul, :y, :x},
    {:add, :y, 1},
    {:mul, :z, :y},
    {:mul, :y, 0},
    {:add, :y, :w},
    {:add, :y, 12},
    {:mul, :y, :x},
    {:add, :z, :y}
  ],
  [
    {:inp, :w},
    {:mul, :x, 0},
    {:add, :x, :z},
    {:mod, :x, 26},
    {:div, :z, 1},
    {:add, :x, 14},
    {:eql, :x, :w},
    {:eql, :x, 0},
    {:mul, :y, 0},
    {:add, :y, 25},
    {:mul, :y, :x},
    {:add, :y, 1},
    {:mul, :z, :y},
    {:mul, :y, 0},
    {:add, :y, :w},
    {:add, :y, 2},
    {:mul, :y, :x},
    {:add, :z, :y}
  ],
  [
    {:inp, :w},
    {:mul, :x, 0},
    {:add, :x, :z},
    {:mod, :x, 26},
    {:div, :z, 1},
    {:add, :x, 15},
    {:eql, :x, :w},
    {:eql, :x, 0},
    {:mul, :y, 0},
    {:add, :y, 25},
    {:mul, :y, :x},
    {:add, :y, 1},
    {:mul, :z, :y},
    {:mul, :y, 0},
    {:add, :y, :w},
    {:add, :y, 11},
    {:mul, :y, :x},
    {:add, :z, :y}
  ],
  [
    {:inp, :w},
    {:mul, :x, 0},
    {:add, :x, :z},
    {:mod, :x, 26},
    {:div, :z, 26},
    {:add, :x, -16},
    {:eql, :x, :w},
    {:eql, :x, 0},
    {:mul, :y, 0},
    {:add, :y, 25},
    {:mul, :y, :x},
    {:add, :y, 1},
    {:mul, :z, :y},
    {:mul, :y, 0},
    {:add, :y, :w},
    {:add, :y, 4},
    {:mul, :y, :x},
    {:add, :z, :y}
  ],
  [
    {:inp, :w},
    {:mul, :x, 0},
    {:add, :x, :z},
    {:mod, :x, 26},
    {:div, :z, 1},
    {:add, :x, 14},
    {:eql, :x, :w},
    {:eql, :x, 0},
    {:mul, :y, 0},
    {:add, :y, 25},
    {:mul, :y, :x},
    {:add, :y, 1},
    {:mul, :z, :y},
    {:mul, :y, 0},
    {:add, :y, :w},
    {:add, :y, 12},
    {:mul, :y, :x},
    {:add, :z, :y}
  ],
  [
    {:inp, :w},
    {:mul, :x, 0},
    {:add, :x, :z},
    {:mod, :x, 26},
    {:div, :z, 1},
    {:add, :x, 15},
    {:eql, :x, :w},
    {:eql, :x, 0},
    {:mul, :y, 0},
    {:add, :y, 25},
    {:mul, :y, :x},
    {:add, :y, 1},
    {:mul, :z, :y},
    {:mul, :y, 0},
    {:add, :y, :w},
    {:add, :y, 9},
    {:mul, :y, :x},
    {:add, :z, :y}
  ],
  [
    {:inp, :w},
    {:mul, :x, 0},
    {:add, :x, :z},
    {:mod, :x, 26},
    {:div, :z, 26},
    {:add, :x, -7},
    {:eql, :x, :w},
    {:eql, :x, 0},
    {:mul, :y, 0},
    {:add, :y, 25},
    {:mul, :y, :x},
    {:add, :y, 1},
    {:mul, :z, :y},
    {:mul, :y, 0},
    {:add, :y, :w},
    {:add, :y, 10},
    {:mul, :y, :x},
    {:add, :z, :y}
  ],
  [
    {:inp, :w},
    {:mul, :x, 0},
    {:add, :x, :z},
    {:mod, :x, 26},
    {:div, :z, 26},
    {:add, :x, -11},
    {:eql, :x, :w},
    {:eql, :x, 0},
    {:mul, :y, 0},
    {:add, :y, 25},
    {:mul, :y, :x},
    {:add, :y, 1},
    {:mul, :z, :y},
    {:mul, :y, 0},
    {:add, :y, :w},
    {:add, :y, 11},
    {:mul, :y, :x},
    {:add, :z, :y}
  ],
  [
    {:inp, :w},
    {:mul, :x, 0},
    {:add, :x, :z},
    {:mod, :x, 26},
    {:div, :z, 26},
    {:add, :x, -6},
    {:eql, :x, :w},
    {:eql, :x, 0},
    {:mul, :y, 0},
    {:add, :y, 25},
    {:mul, :y, :x},
    {:add, :y, 1},
    {:mul, :z, :y},
    {:mul, :y, 0},
    {:add, :y, :w},
    {:add, :y, 6},
    {:mul, :y, :x},
    {:add, :z, :y}
  ],
  [
    {:inp, :w},
    {:mul, :x, 0},
    {:add, :x, :z},
    {:mod, :x, 26},
    {:div, :z, 26},
    {:add, :x, -11},
    {:eql, :x, :w},
    {:eql, :x, 0},
    {:mul, :y, 0},
    {:add, :y, 25},
    {:mul, :y, :x},
    {:add, :y, 1},
    {:mul, :z, :y},
    {:mul, :y, 0},
    {:add, :y, :w},
    {:add, :y, 15},
    {:mul, :y, :x},
    {:add, :z, :y}
  ]
]
```

```elixir
List.myers_difference(hd(digits), Enum.at(digits, 4))
```

<!-- livebook:{"output":true} -->

```
[
  eq: [{:inp, :w}, {:mul, :x, 0}, {:add, :x, :z}, {:mod, :x, 26}],
  del: [{:div, :z, 1}, {:add, :x, 11}],
  ins: [{:div, :z, 26}, {:add, :x, -3}],
  eq: [
    {:eql, :x, :w},
    {:eql, :x, 0},
    {:mul, :y, 0},
    {:add, :y, 25},
    {:mul, :y, :x},
    {:add, :y, 1},
    {:mul, :z, :y},
    {:mul, :y, 0},
    {:add, :y, :w}
  ],
  del: [{:add, :y, 16}],
  ins: [{:add, :y, 12}],
  eq: [{:mul, :y, :x}, {:add, :z, :y}]
]
```

```elixir
params =
  Enum.map(digits, fn sub ->
    [5, 15]
    |> Enum.map(&Enum.at(sub, &1))
    |> Enum.map(&elem(&1, 2))
  end)
```

<!-- livebook:{"output":true} -->

```
[
  [11, 16],
  ~c"\f\v",
  ~c"\r\f",
  [-5, 12],
  [-3, 12],
  [14, 2],
  [15, 11],
  [-16, 4],
  [14, 12],
  [15, 9],
  [-7, 10],
  [-11, 11],
  [-6, 6],
  [-11, 15]
]
```

```elixir
defmodule ALU do
  def solve(params, range) do
    params |> solve(0, [], range) |> Enum.reverse() |> Integer.undigits()
  end

  defp solve([], _z, acc, _range), do: acc

  defp solve([[a, b] | rest], z, acc, range) when a > 0 do
    Enum.find_value(range, fn w ->
      solve(rest, 26 * z + w + b, [w | acc], range)
    end)
  end

  defp solve([[a, _] | rest], z, acc, range) when a < 0 do
    value = rem(z, 26) + a

    if value in range do
      solve(rest, div(z, 26), [value | acc], range)
    end
  end
end
```

<!-- livebook:{"output":true} -->

```
{:module, ALU, <<70, 79, 82, 49, 0, 0, 10, ...>>, {:solve, 4}}
```

## Part 1

```elixir
ALU.solve(params, 9..1//-1)
```

<!-- livebook:{"output":true} -->

```
41299994879959
```

## Part 2

```elixir
ALU.solve(params, 1..9)
```

<!-- livebook:{"output":true} -->

```
11189561113216
```