The initialization program (your puzzle input) can either update the bitmask or write a value to memory. Values and memory addresses are both 36-bit unsigned integers. For example, ignoring bitmasks for a moment, a line like **mem[8] = 11** would write the value 11 to memory address 8.

The bitmask is always given as a string of 36 bits, written with the most significant bit (representing 2^35) on the left and the least significant bit (2^0, that is, the 1s bit) on the right. The current bitmask is applied to values immediately before they are written to memory: a 0 or 1 overwrites the corresponding bit in the value, while an X leaves the bit in the value unchanged.

For example, consider the following program:

This program starts by specifying a bitmask (mask = ....). The mask it specifies will overwrite two bits in every written value: the 2s bit is overwritten with 0, and the 64s bit is overwritten with 1.

mask = XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X mem[8] = 11 mem[7] = 101 mem[8] = 0

The program then attempts to write the value 11 to memory address 8. By expanding everything out to individual bits, the mask is applied as follows:

So, because of the mask, the value 73 is written to memory address 8 instead. Then, the program tries to write 101 to address 7:

value: 000000000000000000000000000000001011 (decimal 11) mask: XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X result: 000000000000000000000000000001001001 (decimal 73)

This time, the mask has no effect, as the bits it overwrote were already the values the mask tried to set. Finally, the program tries to write 0 to address 8:

value: 000000000000000000000000000001100101 (decimal 101) mask: XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X result: 000000000000000000000000000001100101 (decimal 101)

64 is written to address 8 instead, overwriting the value that was there previously.

value: 000000000000000000000000000000000000 (decimal 0) mask: XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X result: 000000000000000000000000000001000000 (decimal 64)

To initialize your ferry's docking program, you need the sum of all values left in memory after the initialization program completes. (The entire 36-bit address space begins initialized to the value 0 at every address.) In the above example, only two values in memory are not zero - 101 (at address 7) and 64 (at address 8) - producing a sum of 165.

Execute the initialization program.

## VP 27.1: Bitmask (15 pts)

Use the program in this file:What is the sum of all values left in memory after it completes? (Do not truncate the sum to 36 bits.)

https://samsclass.info/COMSC132/proj/VP27The flag is that value, in base 10.

- If the bitmask bit is 0, the corresponding memory address bit is unchanged.
- If the bitmask bit is 1, the corresponding memory address bit is overwritten with 1.
- If the bitmask bit is X, the corresponding memory address bit is
**floating**.

For example, consider the following program:

When this program goes to write to memory address 42, it first applies the bitmask:

mask = 000000000000000000000000000000X1001X mem[42] = 100 mask = 00000000000000000000000000000000X0XX mem[26] = 1

After applying the mask, four bits are overwritten, three of which are different, and two of which are floating. Floating bits take on every possible combination of values; with two floating bits, four actual memory addresses are written:

address: 000000000000000000000000000000101010 (decimal 42) mask: 000000000000000000000000000000X1001X result: 000000000000000000000000000000X1101X

Next, the program is about to write to memory address 26 with a different bitmask:

000000000000000000000000000000011010 (decimal 26) 000000000000000000000000000000011011 (decimal 27) 000000000000000000000000000000111010 (decimal 58) 000000000000000000000000000000111011 (decimal 59)

This results in an address with three floating bits, causing writes to eight memory addresses:

address: 000000000000000000000000000000011010 (decimal 26) mask: 00000000000000000000000000000000X0XX result: 00000000000000000000000000000001X0XX

The entire 36-bit address space still begins initialized to the value 0 at every address, and you still need the sum of all values left in memory at the end of the program. In this example, the sum is 208.

000000000000000000000000000000010000 (decimal 16) 000000000000000000000000000000010001 (decimal 17) 000000000000000000000000000000010010 (decimal 18) 000000000000000000000000000000010011 (decimal 19) 000000000000000000000000000000011000 (decimal 24) 000000000000000000000000000000011001 (decimal 25) 000000000000000000000000000000011010 (decimal 26) 000000000000000000000000000000011011 (decimal 27)

Execute the initialization program using an emulator for a version 2 decoder chip. What is the sum of all values left in memory after it completes?

## VP 27.2: Bitmask Version 2 (15 pts extra)

Use the program in this file:What is the sum of all values left in memory after it completes? (Do not truncate the sum to 36 bits.)

https://samsclass.info/COMSC132/proj/VP27The flag is that value, in base 10.

Posted 9-7-24

Video added 10-9-24