a14.tt

use 'hash' stand-alone

data value <"1">,
  address <"1">

templates setMask
  @: [x00x] -> $(-3..1);
  $... -> #
  $@!
  when <='1'> do @: $@::shift&{left: 1, fill: [x80x]};
  otherwise @: $@::shift&{left: 1, fill: [x00x]};
end setMask

templates clearMask
  @: [xffx] -> $(-3..1);
  $... -> #
  $@!
  when <='0'> do @: $@::shift&{left: 1, fill: [x7fx]};
  otherwise @: $@::shift&{left: 1, fill: [xffx]};
end clearMask

composer parseLine
  <mask|set>
  rule mask: (<='mask = '>) <'.{36}'> -> {set: $ -> setMask, clear: $ -> clearMask}
  rule set: (<='mem['>) {address: <INT"1">, (<='] = '>) value: <INT"1">}
end parseLine

def dockingProgram: [$IN::lines -> parseLine];

sink debugPrint
  '$.mask.set; $.mask.clear;
$.memory... ... -> '$::asInteger -> \(<1..> '$; '!\);';
' -> !OUT::write 
end debugPrint

templates getBit
  def pos: $;
  [x00 00 00 00 01x] -> $::shift&{left: $pos, fill: [x00x]} !
end getBit

templates run&{v2:}
  @:{memory:[] -> hash/Map&{key: :(address:), value: :(value:)}, mask:{set: [x00x], clear: [xffx]}};
  $... -> #
  $@.memory -> \(
    @: 0"1";
    $::entries -> $.value -> @: $@ + $;
    $@!
  \)!

  when <´{}´ {set: <>}> do @.mask: $;
  when <?($v2 <=0>)> do
    // $@ -> !debugPrint
    {address: $.address, value: ((($.value::asBytes and $@.mask.clear) or $@.mask.set) -> $::asInteger)"1"} -> @.memory::put -> !VOID
  otherwise
    def instruction: $;
    def floating: (($@.mask.set xor $@.mask.clear) and [x 0f ffff ffff x]);
    [0..35 -> getBit] -> \floats(
      @:[($instruction.address::asBytes or $@run.mask.set)];
      $... -> #
      $@... !
      when <?(($ and $floating) <=$>)> do
        def bit: $;
        @: [$@... -> \(($ or $bit)! ($ and $bit::inverse)!\)];
    \floats) -> $::asInteger -> \(
      {address: ($)"1", value: $instruction.value} -> @run.memory::put -> !VOID
    \) -> !VOID
end run

test 'part 1'
  def input: [
    'mask = XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X',
    'mem[8] = 11',
    'mem[7] = 101',
    'mem[8] = 0'
  ];

  def program: [$input... -> parseLine];
  assert $program -> run&{v2:0} <=165> 'runs correctly'
end 'part 1'

def part1: $dockingProgram -> run&{v2:0};
'$part1;
' -> !OUT::write

test 'part 2'
  def input: [
    'mask = 000000000000000000000000000000X1001X',
    'mem[42] = 100',
    'mask = 00000000000000000000000000000000X0XX',
    'mem[26] = 1'
  ];

  def program: [$input... -> parseLine];
  assert $program -> run&{v2:1} <=208> 'runs correctly'
end 'part 2'

def part2: $dockingProgram -> run&{v2:1};
'$part2;
' -> !OUT::write