[INFO] cloning repository https://github.com/Awfa/advent_of_code_2019
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/Awfa/advent_of_code_2019" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FAwfa%2Fadvent_of_code_2019", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FAwfa%2Fadvent_of_code_2019'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 2d75360aabe9fa7e9ad65021d8a2d38e926db8b3
[INFO] testing Awfa/advent_of_code_2019 against 1.60.0 for beta-1.61-1
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FAwfa%2Fadvent_of_code_2019" "/workspace/builds/worker-13/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-13/source'...
[INFO] [stderr] done.
[INFO] validating manifest of git repo https://github.com/Awfa/advent_of_code_2019 on toolchain 1.60.0
[INFO] running `Command { std: "/workspace/cargo-home/bin/cargo" "+1.60.0" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] started tweaking git repo https://github.com/Awfa/advent_of_code_2019
[INFO] finished tweaking git repo https://github.com/Awfa/advent_of_code_2019
[INFO] tweaked toml for git repo https://github.com/Awfa/advent_of_code_2019 written to /workspace/builds/worker-13/source/Cargo.toml
[INFO] crate git repo https://github.com/Awfa/advent_of_code_2019 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: "/workspace/cargo-home/bin/cargo" "+1.60.0" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-13/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-13/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:eaef2f80f755933c374d2ae5edccceec0c1312ceb8a4e0b6404e8ab76561e1e5" "/opt/rustwide/cargo-home/bin/cargo" "+1.60.0" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stderr] WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.
[INFO] [stdout] 3929381f7d8241c3053d415eb6f961664a3bdd43b0bd1ffb6ec758f2742fb5d9
[INFO] running `Command { std: "docker" "start" "-a" "3929381f7d8241c3053d415eb6f961664a3bdd43b0bd1ffb6ec758f2742fb5d9", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "3929381f7d8241c3053d415eb6f961664a3bdd43b0bd1ffb6ec758f2742fb5d9", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "3929381f7d8241c3053d415eb6f961664a3bdd43b0bd1ffb6ec758f2742fb5d9", kill_on_drop: false }`
[INFO] [stdout] 3929381f7d8241c3053d415eb6f961664a3bdd43b0bd1ffb6ec758f2742fb5d9
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-13/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-13/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:eaef2f80f755933c374d2ae5edccceec0c1312ceb8a4e0b6404e8ab76561e1e5" "/opt/rustwide/cargo-home/bin/cargo" "+1.60.0" "build" "--frozen" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr] WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.
[INFO] [stdout] 59053bfa1330fc67f107332325f42e78e139d15f602b082f2f2bb53082d79b9e
[INFO] running `Command { std: "docker" "start" "-a" "59053bfa1330fc67f107332325f42e78e139d15f602b082f2f2bb53082d79b9e", kill_on_drop: false }`
[INFO] [stderr]    Compiling proc-macro2 v1.0.6
[INFO] [stderr]    Compiling syn v1.0.11
[INFO] [stderr]    Compiling quote v1.0.2
[INFO] [stderr]    Compiling opcode-macro v0.1.0 (/opt/rustwide/workdir/opcode-macro)
[INFO] [stdout] warning: field is never read: `separator`
[INFO] [stdout]    --> opcode-macro/src/lib.rs:132:5
[INFO] [stdout]     |
[INFO] [stdout] 132 |     separator: Token![:],
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(dead_code)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: field is never read: `keyword`
[INFO] [stdout]    --> opcode-macro/src/lib.rs:148:9
[INFO] [stdout]     |
[INFO] [stdout] 148 |         keyword: kw::ReadOnly
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: field is never read: `keyword`
[INFO] [stdout]    --> opcode-macro/src/lib.rs:151:9
[INFO] [stdout]     |
[INFO] [stdout] 151 |         keyword: kw::Writable
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: field is never read: `separator`
[INFO] [stdout]    --> opcode-macro/src/lib.rs:175:9
[INFO] [stdout]     |
[INFO] [stdout] 175 |         separator: Token![:],
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: field is never read: `separator`
[INFO] [stdout]    --> opcode-macro/src/lib.rs:183:9
[INFO] [stdout]     |
[INFO] [stdout] 183 |         separator: Token![:],
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 5 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]    Compiling advent_of_code_2019 v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] pub enum OpCode
[INFO] [stdout] {
[INFO] [stdout]     Add, Multiply, Input, Output, JumpIfTrue, JumpIfFalse, LessThan, Equals,
[INFO] [stdout]     End
[INFO] [stdout] } impl OpCode
[INFO] [stdout] {
[INFO] [stdout]     fn
[INFO] [stdout]     get_current_instruction(memory : & [EmulatorMemoryType],
[INFO] [stdout]     instruction_pointer : usize) -> Result <
[INFO] [stdout]     (OpCode, impl Iterator < Item = Result < ParameterMode, EmulatorError >>),
[INFO] [stdout]     EmulatorError >
[INFO] [stdout]     {
[INFO] [stdout]         let instruction_value = *
[INFO] [stdout]         memory.get(instruction_pointer).ok_or(EmulatorError ::
[INFO] [stdout]         InstructionPointerOutOfBounds { position : instruction_pointer, }) ? ;
[INFO] [stdout]         let instruction = match(instruction_value % 100)
[INFO] [stdout]         {
[INFO] [stdout]             1 => Ok(OpCode :: Add), 2 => Ok(OpCode :: Multiply), 3 =>
[INFO] [stdout]             Ok(OpCode :: Input), 4 => Ok(OpCode :: Output), 5 =>
[INFO] [stdout]             Ok(OpCode :: JumpIfTrue), 6 => Ok(OpCode :: JumpIfFalse), 7 =>
[INFO] [stdout]             Ok(OpCode :: LessThan), 8 => Ok(OpCode :: Equals), 99 =>
[INFO] [stdout]             Ok(OpCode :: End), _ =>
[INFO] [stdout]             Err(EmulatorError :: InvalidInstruction
[INFO] [stdout]             {
[INFO] [stdout]                 value_found : instruction_value, position :
[INFO] [stdout]                 instruction_pointer
[INFO] [stdout]             })
[INFO] [stdout]         } ? ; let parameter_mode_iterator =
[INFO] [stdout]         {
[INFO] [stdout]             let mut parameter_mode_digits = instruction_value / 100 ; std ::
[INFO] [stdout]             iter ::
[INFO] [stdout]             from_fn(move ||
[INFO] [stdout]             {
[INFO] [stdout]                 let parameter_mode_digit = parameter_mode_digits % 10 ; let
[INFO] [stdout]                 result = match parameter_mode_digit
[INFO] [stdout]                 {
[INFO] [stdout]                     0 => Ok(ParameterMode :: Position), 1 =>
[INFO] [stdout]                     Ok(ParameterMode :: Immediate), _ =>
[INFO] [stdout]                     Err(EmulatorError :: InvalidParameterMode
[INFO] [stdout]                     {
[INFO] [stdout]                         value_found : parameter_mode_digit, position :
[INFO] [stdout]                         instruction_pointer
[INFO] [stdout]                     }),
[INFO] [stdout]                 } ; parameter_mode_digits /= 10 ; Some(result)
[INFO] [stdout]             })
[INFO] [stdout]         } ; Ok((instruction, parameter_mode_iterator))
[INFO] [stdout]     } fn to_opcode(& self) -> EmulatorMemoryType
[INFO] [stdout]     {
[INFO] [stdout]         match self
[INFO] [stdout]         {
[INFO] [stdout]             OpCode :: Add => 1, OpCode :: Multiply => 2, OpCode :: Input => 3,
[INFO] [stdout]             OpCode :: Output => 4, OpCode :: JumpIfTrue => 5, OpCode ::
[INFO] [stdout]             JumpIfFalse => 6, OpCode :: LessThan => 7, OpCode :: Equals => 8,
[INFO] [stdout]             OpCode :: End => 99,
[INFO] [stdout]         }
[INFO] [stdout]     } fn
[INFO] [stdout]     handle_add(addend1 : EmulatorMemoryType, addend2 : EmulatorMemoryType,
[INFO] [stdout]     dest : & mut EmulatorMemoryType) -> Result < (), EmulatorError >
[INFO] [stdout]     { Ok({ * dest = addend1 + addend2 ; }) } fn
[INFO] [stdout]     handle_multiply(factor1 : EmulatorMemoryType, factor2 :
[INFO] [stdout]     EmulatorMemoryType, dest : & mut EmulatorMemoryType) -> Result < (),
[INFO] [stdout]     EmulatorError > { Ok({ * dest = factor1 * factor2 ; }) } fn handle_input <
[INFO] [stdout]     I : Iterator < Item = Result < EmulatorMemoryType, EmulatorError >> >
[INFO] [stdout]     (input_iter : & mut I, dest : & mut EmulatorMemoryType) -> Result < (),
[INFO] [stdout]     EmulatorError >
[INFO] [stdout]     {
[INFO] [stdout]         Ok({
[INFO] [stdout]             * dest =
[INFO] [stdout]             input_iter.next().ok_or(EmulatorError :: InputNonExistent) ? ? ;
[INFO] [stdout]         })
[INFO] [stdout]     } fn handle_output(value : EmulatorMemoryType) -> Result <
[INFO] [stdout]     EmulatorMemoryType, EmulatorError > { Ok({ value }) } fn
[INFO] [stdout]     handle_jumpiftrue(new_instruction_pointer : & mut Option <
[INFO] [stdout]     EmulatorMemoryType >, value : EmulatorMemoryType, new_address :
[INFO] [stdout]     EmulatorMemoryType) -> Result < (), EmulatorError >
[INFO] [stdout]     {
[INFO] [stdout]         Ok({
[INFO] [stdout]             if value != 0 { * new_instruction_pointer = Some(new_address) ; }
[INFO] [stdout]         })
[INFO] [stdout]     } fn
[INFO] [stdout]     handle_jumpiffalse(new_instruction_pointer : & mut Option <
[INFO] [stdout]     EmulatorMemoryType >, value : EmulatorMemoryType, new_address :
[INFO] [stdout]     EmulatorMemoryType) -> Result < (), EmulatorError >
[INFO] [stdout]     {
[INFO] [stdout]         Ok({
[INFO] [stdout]             if value == 0 { * new_instruction_pointer = Some(new_address) ; }
[INFO] [stdout]         })
[INFO] [stdout]     } fn
[INFO] [stdout]     handle_lessthan(left_side : EmulatorMemoryType, right_side :
[INFO] [stdout]     EmulatorMemoryType, dest : & mut EmulatorMemoryType) -> Result < (),
[INFO] [stdout]     EmulatorError >
[INFO] [stdout]     { Ok({ * dest = if left_side < right_side { 1 } else { 0 } ; }) } fn
[INFO] [stdout]     handle_equals(left_side : EmulatorMemoryType, right_side :
[INFO] [stdout]     EmulatorMemoryType, dest : & mut EmulatorMemoryType) -> Result < (),
[INFO] [stdout]     EmulatorError >
[INFO] [stdout]     { Ok({ * dest = if left_side == right_side { 1 } else { 0 } ; }) } fn
[INFO] [stdout]     handle_end() -> Result < (), EmulatorError > { Ok({}) } fn run < I :
[INFO] [stdout]     Iterator < Item = Result < EmulatorMemoryType, EmulatorError >> >
[INFO] [stdout]     (memory : & mut [EmulatorMemoryType], instruction_pointer : usize,
[INFO] [stdout]     input_iter : & mut I) -> Result <
[INFO] [stdout]     (Option < usize >, Option < EmulatorMemoryType >), EmulatorError >
[INFO] [stdout]     {
[INFO] [stdout]         let(instruction, mut parameter_mode_iterator) = OpCode ::
[INFO] [stdout]         get_current_instruction(memory, instruction_pointer) ? ; let mut
[INFO] [stdout]         new_instruction_pointer = None ; match instruction
[INFO] [stdout]         {
[INFO] [stdout]             OpCode :: Add =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 3usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 3usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 3usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let addend1 : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let addend2 : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let dest : & mut EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 2usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ;
[INFO] [stdout]                         memory.get_mut(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     {
[INFO] [stdout]                         return
[INFO] [stdout]                         Err(EmulatorError :: UnexpectedParameterModeForWritable
[INFO] [stdout]                         {
[INFO] [stdout]                             value_found : 1, position : instruction_pointer + 2usize +
[INFO] [stdout]                             1,
[INFO] [stdout]                         })
[INFO] [stdout]                     }
[INFO] [stdout]                 } ; let _ : () = OpCode :: handle_add(addend1, addend2, dest)
[INFO] [stdout]                 ? ; Ok((Some(instruction_pointer + 4usize), None))
[INFO] [stdout]             }, OpCode :: Multiply =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 3usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 3usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 3usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let factor1 : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let factor2 : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let dest : & mut EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 2usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ;
[INFO] [stdout]                         memory.get_mut(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     {
[INFO] [stdout]                         return
[INFO] [stdout]                         Err(EmulatorError :: UnexpectedParameterModeForWritable
[INFO] [stdout]                         {
[INFO] [stdout]                             value_found : 1, position : instruction_pointer + 2usize +
[INFO] [stdout]                             1,
[INFO] [stdout]                         })
[INFO] [stdout]                     }
[INFO] [stdout]                 } ; let _ : () = OpCode ::
[INFO] [stdout]                 handle_multiply(factor1, factor2, dest) ? ;
[INFO] [stdout]                 Ok((Some(instruction_pointer + 4usize), None))
[INFO] [stdout]             }, OpCode :: Input =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 1usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 1usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 1usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let dest : & mut EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ;
[INFO] [stdout]                         memory.get_mut(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     {
[INFO] [stdout]                         return
[INFO] [stdout]                         Err(EmulatorError :: UnexpectedParameterModeForWritable
[INFO] [stdout]                         {
[INFO] [stdout]                             value_found : 1, position : instruction_pointer + 0usize +
[INFO] [stdout]                             1,
[INFO] [stdout]                         })
[INFO] [stdout]                     }
[INFO] [stdout]                 } ; let _ : () = OpCode :: handle_input(input_iter, dest) ? ;
[INFO] [stdout]                 Ok((Some(instruction_pointer + 2usize), None))
[INFO] [stdout]             }, OpCode :: Output =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 1usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 1usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 1usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let value : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let output : EmulatorMemoryType = OpCode ::
[INFO] [stdout]                 handle_output(value) ? ;
[INFO] [stdout]                 Ok((Some(instruction_pointer + 2usize), Some(output)))
[INFO] [stdout]             }, OpCode :: JumpIfTrue =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 2usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 2usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 2usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let value : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let new_address : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let _ : () = OpCode ::
[INFO] [stdout]                 handle_jumpiftrue(& mut new_instruction_pointer, value,
[INFO] [stdout]                 new_address) ? ;
[INFO] [stdout]                 Ok((Some(new_instruction_pointer.map(| value | std :: convert
[INFO] [stdout]                 :: TryInto :: < usize > ::
[INFO] [stdout]                 try_into(value).or(Err(EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                 {
[INFO] [stdout]                     value_found : value, position : 0
[INFO] [stdout]                 }))).unwrap_or(Ok(instruction_pointer + 3usize)) ?), None))
[INFO] [stdout]             }, OpCode :: JumpIfFalse =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 2usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 2usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 2usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let value : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let new_address : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let _ : () = OpCode ::
[INFO] [stdout]                 handle_jumpiffalse(& mut new_instruction_pointer, value,
[INFO] [stdout]                 new_address) ? ;
[INFO] [stdout]                 Ok((Some(new_instruction_pointer.map(| value | std :: convert
[INFO] [stdout]                 :: TryInto :: < usize > ::
[INFO] [stdout]                 try_into(value).or(Err(EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                 {
[INFO] [stdout]                     value_found : value, position : 0
[INFO] [stdout]                 }))).unwrap_or(Ok(instruction_pointer + 3usize)) ?), None))
[INFO] [stdout]             }, OpCode :: LessThan =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 3usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 3usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 3usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let left_side : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let right_side : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let dest : & mut EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 2usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ;
[INFO] [stdout]                         memory.get_mut(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     {
[INFO] [stdout]                         return
[INFO] [stdout]                         Err(EmulatorError :: UnexpectedParameterModeForWritable
[INFO] [stdout]                         {
[INFO] [stdout]                             value_found : 1, position : instruction_pointer + 2usize +
[INFO] [stdout]                             1,
[INFO] [stdout]                         })
[INFO] [stdout]                     }
[INFO] [stdout]                 } ; let _ : () = OpCode ::
[INFO] [stdout]                 handle_lessthan(left_side, right_side, dest) ? ;
[INFO] [stdout]                 Ok((Some(instruction_pointer + 4usize), None))
[INFO] [stdout]             }, OpCode :: Equals =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 3usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 3usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 3usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let left_side : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let right_side : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let dest : & mut EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 2usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ;
[INFO] [stdout]                         memory.get_mut(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     {
[INFO] [stdout]                         return
[INFO] [stdout]                         Err(EmulatorError :: UnexpectedParameterModeForWritable
[INFO] [stdout]                         {
[INFO] [stdout]                             value_found : 1, position : instruction_pointer + 2usize +
[INFO] [stdout]                             1,
[INFO] [stdout]                         })
[INFO] [stdout]                     }
[INFO] [stdout]                 } ; let _ : () = OpCode ::
[INFO] [stdout]                 handle_equals(left_side, right_side, dest) ? ;
[INFO] [stdout]                 Ok((Some(instruction_pointer + 4usize), None))
[INFO] [stdout]             }, OpCode :: End =>
[INFO] [stdout]             { let _ : () = OpCode :: handle_end() ? ; Ok((None, None)) }
[INFO] [stdout]         }
[INFO] [stdout]     }
[INFO] [stdout] }
[INFO] [stderr]     Finished dev [unoptimized + debuginfo] target(s) in 22.56s
[INFO] running `Command { std: "docker" "inspect" "59053bfa1330fc67f107332325f42e78e139d15f602b082f2f2bb53082d79b9e", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "59053bfa1330fc67f107332325f42e78e139d15f602b082f2f2bb53082d79b9e", kill_on_drop: false }`
[INFO] [stdout] 59053bfa1330fc67f107332325f42e78e139d15f602b082f2f2bb53082d79b9e
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-13/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-13/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:eaef2f80f755933c374d2ae5edccceec0c1312ceb8a4e0b6404e8ab76561e1e5" "/opt/rustwide/cargo-home/bin/cargo" "+1.60.0" "test" "--frozen" "--no-run" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] e5b67e85151ca41d6051bde88f62664055cfbab1650a7d4cd3dd594c42c67bf7
[INFO] [stderr] WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.
[INFO] running `Command { std: "docker" "start" "-a" "e5b67e85151ca41d6051bde88f62664055cfbab1650a7d4cd3dd594c42c67bf7", kill_on_drop: false }`
[INFO] [stderr]    Compiling advent_of_code_2019 v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] warning: field is never read: `separator`
[INFO] [stdout]    --> opcode-macro/src/lib.rs:132:5
[INFO] [stdout]     |
[INFO] [stdout] 132 |     separator: Token![:],
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(dead_code)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: field is never read: `keyword`
[INFO] [stdout]    --> opcode-macro/src/lib.rs:148:9
[INFO] [stdout]     |
[INFO] [stdout] 148 |         keyword: kw::ReadOnly
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: field is never read: `keyword`
[INFO] [stdout]    --> opcode-macro/src/lib.rs:151:9
[INFO] [stdout]     |
[INFO] [stdout] 151 |         keyword: kw::Writable
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: field is never read: `separator`
[INFO] [stdout]    --> opcode-macro/src/lib.rs:175:9
[INFO] [stdout]     |
[INFO] [stdout] 175 |         separator: Token![:],
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: field is never read: `separator`
[INFO] [stdout]    --> opcode-macro/src/lib.rs:183:9
[INFO] [stdout]     |
[INFO] [stdout] 183 |         separator: Token![:],
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 5 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] pub enum OpCode
[INFO] [stdout] {
[INFO] [stdout]     Add, Multiply, Input, Output, JumpIfTrue, JumpIfFalse, LessThan, Equals,
[INFO] [stdout]     End
[INFO] [stdout] } impl OpCode
[INFO] [stdout] {
[INFO] [stdout]     fn
[INFO] [stdout]     get_current_instruction(memory : & [EmulatorMemoryType],
[INFO] [stdout]     instruction_pointer : usize) -> Result <
[INFO] [stdout]     (OpCode, impl Iterator < Item = Result < ParameterMode, EmulatorError >>),
[INFO] [stdout]     EmulatorError >
[INFO] [stdout]     {
[INFO] [stdout]         let instruction_value = *
[INFO] [stdout]         memory.get(instruction_pointer).ok_or(EmulatorError ::
[INFO] [stdout]         InstructionPointerOutOfBounds { position : instruction_pointer, }) ? ;
[INFO] [stdout]         let instruction = match(instruction_value % 100)
[INFO] [stdout]         {
[INFO] [stdout]             1 => Ok(OpCode :: Add), 2 => Ok(OpCode :: Multiply), 3 =>
[INFO] [stdout]             Ok(OpCode :: Input), 4 => Ok(OpCode :: Output), 5 =>
[INFO] [stdout]             Ok(OpCode :: JumpIfTrue), 6 => Ok(OpCode :: JumpIfFalse), 7 =>
[INFO] [stdout]             Ok(OpCode :: LessThan), 8 => Ok(OpCode :: Equals), 99 =>
[INFO] [stdout]             Ok(OpCode :: End), _ =>
[INFO] [stdout]             Err(EmulatorError :: InvalidInstruction
[INFO] [stdout]             {
[INFO] [stdout]                 value_found : instruction_value, position :
[INFO] [stdout]                 instruction_pointer
[INFO] [stdout]             })
[INFO] [stdout]         } ? ; let parameter_mode_iterator =
[INFO] [stdout]         {
[INFO] [stdout]             let mut parameter_mode_digits = instruction_value / 100 ; std ::
[INFO] [stdout]             iter ::
[INFO] [stdout]             from_fn(move ||
[INFO] [stdout]             {
[INFO] [stdout]                 let parameter_mode_digit = parameter_mode_digits % 10 ; let
[INFO] [stdout]                 result = match parameter_mode_digit
[INFO] [stdout]                 {
[INFO] [stdout]                     0 => Ok(ParameterMode :: Position), 1 =>
[INFO] [stdout]                     Ok(ParameterMode :: Immediate), _ =>
[INFO] [stdout]                     Err(EmulatorError :: InvalidParameterMode
[INFO] [stdout]                     {
[INFO] [stdout]                         value_found : parameter_mode_digit, position :
[INFO] [stdout]                         instruction_pointer
[INFO] [stdout]                     }),
[INFO] [stdout]                 } ; parameter_mode_digits /= 10 ; Some(result)
[INFO] [stdout]             })
[INFO] [stdout]         } ; Ok((instruction, parameter_mode_iterator))
[INFO] [stdout]     } fn to_opcode(& self) -> EmulatorMemoryType
[INFO] [stdout]     {
[INFO] [stdout]         match self
[INFO] [stdout]         {
[INFO] [stdout]             OpCode :: Add => 1, OpCode :: Multiply => 2, OpCode :: Input => 3,
[INFO] [stdout]             OpCode :: Output => 4, OpCode :: JumpIfTrue => 5, OpCode ::
[INFO] [stdout]             JumpIfFalse => 6, OpCode :: LessThan => 7, OpCode :: Equals => 8,
[INFO] [stdout]             OpCode :: End => 99,
[INFO] [stdout]         }
[INFO] [stdout]     } fn
[INFO] [stdout]     handle_add(addend1 : EmulatorMemoryType, addend2 : EmulatorMemoryType,
[INFO] [stdout]     dest : & mut EmulatorMemoryType) -> Result < (), EmulatorError >
[INFO] [stdout]     { Ok({ * dest = addend1 + addend2 ; }) } fn
[INFO] [stdout]     handle_multiply(factor1 : EmulatorMemoryType, factor2 :
[INFO] [stdout]     EmulatorMemoryType, dest : & mut EmulatorMemoryType) -> Result < (),
[INFO] [stdout]     EmulatorError > { Ok({ * dest = factor1 * factor2 ; }) } fn handle_input <
[INFO] [stdout]     I : Iterator < Item = Result < EmulatorMemoryType, EmulatorError >> >
[INFO] [stdout]     (input_iter : & mut I, dest : & mut EmulatorMemoryType) -> Result < (),
[INFO] [stdout]     EmulatorError >
[INFO] [stdout]     {
[INFO] [stdout]         Ok({
[INFO] [stdout]             * dest =
[INFO] [stdout]             input_iter.next().ok_or(EmulatorError :: InputNonExistent) ? ? ;
[INFO] [stdout]         })
[INFO] [stdout]     } fn handle_output(value : EmulatorMemoryType) -> Result <
[INFO] [stdout]     EmulatorMemoryType, EmulatorError > { Ok({ value }) } fn
[INFO] [stdout]     handle_jumpiftrue(new_instruction_pointer : & mut Option <
[INFO] [stdout]     EmulatorMemoryType >, value : EmulatorMemoryType, new_address :
[INFO] [stdout]     EmulatorMemoryType) -> Result < (), EmulatorError >
[INFO] [stdout]     {
[INFO] [stdout]         Ok({
[INFO] [stdout]             if value != 0 { * new_instruction_pointer = Some(new_address) ; }
[INFO] [stdout]         })
[INFO] [stdout]     } fn
[INFO] [stdout]     handle_jumpiffalse(new_instruction_pointer : & mut Option <
[INFO] [stdout]     EmulatorMemoryType >, value : EmulatorMemoryType, new_address :
[INFO] [stdout]     EmulatorMemoryType) -> Result < (), EmulatorError >
[INFO] [stdout]     {
[INFO] [stdout]         Ok({
[INFO] [stdout]             if value == 0 { * new_instruction_pointer = Some(new_address) ; }
[INFO] [stdout]         })
[INFO] [stdout]     } fn
[INFO] [stdout]     handle_lessthan(left_side : EmulatorMemoryType, right_side :
[INFO] [stdout]     EmulatorMemoryType, dest : & mut EmulatorMemoryType) -> Result < (),
[INFO] [stdout]     EmulatorError >
[INFO] [stdout]     { Ok({ * dest = if left_side < right_side { 1 } else { 0 } ; }) } fn
[INFO] [stdout]     handle_equals(left_side : EmulatorMemoryType, right_side :
[INFO] [stdout]     EmulatorMemoryType, dest : & mut EmulatorMemoryType) -> Result < (),
[INFO] [stdout]     EmulatorError >
[INFO] [stdout]     { Ok({ * dest = if left_side == right_side { 1 } else { 0 } ; }) } fn
[INFO] [stdout]     handle_end() -> Result < (), EmulatorError > { Ok({}) } fn run < I :
[INFO] [stdout]     Iterator < Item = Result < EmulatorMemoryType, EmulatorError >> >
[INFO] [stdout]     (memory : & mut [EmulatorMemoryType], instruction_pointer : usize,
[INFO] [stdout]     input_iter : & mut I) -> Result <
[INFO] [stdout]     (Option < usize >, Option < EmulatorMemoryType >), EmulatorError >
[INFO] [stdout]     {
[INFO] [stdout]         let(instruction, mut parameter_mode_iterator) = OpCode ::
[INFO] [stdout]         get_current_instruction(memory, instruction_pointer) ? ; let mut
[INFO] [stdout]         new_instruction_pointer = None ; match instruction
[INFO] [stdout]         {
[INFO] [stdout]             OpCode :: Add =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 3usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 3usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 3usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let addend1 : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let addend2 : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let dest : & mut EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 2usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ;
[INFO] [stdout]                         memory.get_mut(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     {
[INFO] [stdout]                         return
[INFO] [stdout]                         Err(EmulatorError :: UnexpectedParameterModeForWritable
[INFO] [stdout]                         {
[INFO] [stdout]                             value_found : 1, position : instruction_pointer + 2usize +
[INFO] [stdout]                             1,
[INFO] [stdout]                         })
[INFO] [stdout]                     }
[INFO] [stdout]                 } ; let _ : () = OpCode :: handle_add(addend1, addend2, dest)
[INFO] [stdout]                 ? ; Ok((Some(instruction_pointer + 4usize), None))
[INFO] [stdout]             }, OpCode :: Multiply =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 3usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 3usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 3usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let factor1 : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let factor2 : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let dest : & mut EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 2usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ;
[INFO] [stdout]                         memory.get_mut(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     {
[INFO] [stdout]                         return
[INFO] [stdout]                         Err(EmulatorError :: UnexpectedParameterModeForWritable
[INFO] [stdout]                         {
[INFO] [stdout]                             value_found : 1, position : instruction_pointer + 2usize +
[INFO] [stdout]                             1,
[INFO] [stdout]                         })
[INFO] [stdout]                     }
[INFO] [stdout]                 } ; let _ : () = OpCode ::
[INFO] [stdout]                 handle_multiply(factor1, factor2, dest) ? ;
[INFO] [stdout]                 Ok((Some(instruction_pointer + 4usize), None))
[INFO] [stdout]             }, OpCode :: Input =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 1usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 1usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 1usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let dest : & mut EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ;
[INFO] [stdout]                         memory.get_mut(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     {
[INFO] [stdout]                         return
[INFO] [stdout]                         Err(EmulatorError :: UnexpectedParameterModeForWritable
[INFO] [stdout]                         {
[INFO] [stdout]                             value_found : 1, position : instruction_pointer + 0usize +
[INFO] [stdout]                             1,
[INFO] [stdout]                         })
[INFO] [stdout]                     }
[INFO] [stdout]                 } ; let _ : () = OpCode :: handle_input(input_iter, dest) ? ;
[INFO] [stdout]                 Ok((Some(instruction_pointer + 2usize), None))
[INFO] [stdout]             }, OpCode :: Output =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 1usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 1usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 1usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let value : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let output : EmulatorMemoryType = OpCode ::
[INFO] [stdout]                 handle_output(value) ? ;
[INFO] [stdout]                 Ok((Some(instruction_pointer + 2usize), Some(output)))
[INFO] [stdout]             }, OpCode :: JumpIfTrue =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 2usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 2usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 2usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let value : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let new_address : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let _ : () = OpCode ::
[INFO] [stdout]                 handle_jumpiftrue(& mut new_instruction_pointer, value,
[INFO] [stdout]                 new_address) ? ;
[INFO] [stdout]                 Ok((Some(new_instruction_pointer.map(| value | std :: convert
[INFO] [stdout]                 :: TryInto :: < usize > ::
[INFO] [stdout]                 try_into(value).or(Err(EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                 {
[INFO] [stdout]                     value_found : value, position : 0
[INFO] [stdout]                 }))).unwrap_or(Ok(instruction_pointer + 3usize)) ?), None))
[INFO] [stdout]             }, OpCode :: JumpIfFalse =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 2usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 2usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 2usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let value : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let new_address : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let _ : () = OpCode ::
[INFO] [stdout]                 handle_jumpiffalse(& mut new_instruction_pointer, value,
[INFO] [stdout]                 new_address) ? ;
[INFO] [stdout]                 Ok((Some(new_instruction_pointer.map(| value | std :: convert
[INFO] [stdout]                 :: TryInto :: < usize > ::
[INFO] [stdout]                 try_into(value).or(Err(EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                 {
[INFO] [stdout]                     value_found : value, position : 0
[INFO] [stdout]                 }))).unwrap_or(Ok(instruction_pointer + 3usize)) ?), None))
[INFO] [stdout]             }, OpCode :: LessThan =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 3usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 3usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 3usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let left_side : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let right_side : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let dest : & mut EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 2usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ;
[INFO] [stdout]                         memory.get_mut(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     {
[INFO] [stdout]                         return
[INFO] [stdout]                         Err(EmulatorError :: UnexpectedParameterModeForWritable
[INFO] [stdout]                         {
[INFO] [stdout]                             value_found : 1, position : instruction_pointer + 2usize +
[INFO] [stdout]                             1,
[INFO] [stdout]                         })
[INFO] [stdout]                     }
[INFO] [stdout]                 } ; let _ : () = OpCode ::
[INFO] [stdout]                 handle_lessthan(left_side, right_side, dest) ? ;
[INFO] [stdout]                 Ok((Some(instruction_pointer + 4usize), None))
[INFO] [stdout]             }, OpCode :: Equals =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 3usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 3usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 3usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let left_side : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let right_side : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let dest : & mut EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 2usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ;
[INFO] [stdout]                         memory.get_mut(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     {
[INFO] [stdout]                         return
[INFO] [stdout]                         Err(EmulatorError :: UnexpectedParameterModeForWritable
[INFO] [stdout]                         {
[INFO] [stdout]                             value_found : 1, position : instruction_pointer + 2usize +
[INFO] [stdout]                             1,
[INFO] [stdout]                         })
[INFO] [stdout]                     }
[INFO] [stdout]                 } ; let _ : () = OpCode ::
[INFO] [stdout]                 handle_equals(left_side, right_side, dest) ? ;
[INFO] [stdout]                 Ok((Some(instruction_pointer + 4usize), None))
[INFO] [stdout]             }, OpCode :: End =>
[INFO] [stdout]             { let _ : () = OpCode :: handle_end() ? ; Ok((None, None)) }
[INFO] [stdout]         }
[INFO] [stdout]     }
[INFO] [stdout] }
[INFO] [stderr]     Finished test [unoptimized + debuginfo] target(s) in 2.49s
[INFO] running `Command { std: "docker" "inspect" "e5b67e85151ca41d6051bde88f62664055cfbab1650a7d4cd3dd594c42c67bf7", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "e5b67e85151ca41d6051bde88f62664055cfbab1650a7d4cd3dd594c42c67bf7", kill_on_drop: false }`
[INFO] [stdout] e5b67e85151ca41d6051bde88f62664055cfbab1650a7d4cd3dd594c42c67bf7
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-13/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-13/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:eaef2f80f755933c374d2ae5edccceec0c1312ceb8a4e0b6404e8ab76561e1e5" "/opt/rustwide/cargo-home/bin/cargo" "+1.60.0" "test" "--frozen", kill_on_drop: false }`
[INFO] [stdout] 7ddcfe11f3bb6bf91252f8464938edfc7a9fafbe6468663ff6ccd466bcba6b47
[INFO] [stderr] WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.
[INFO] running `Command { std: "docker" "start" "-a" "7ddcfe11f3bb6bf91252f8464938edfc7a9fafbe6468663ff6ccd466bcba6b47", kill_on_drop: false }`
[INFO] [stderr] warning: field is never read: `separator`
[INFO] [stderr]    --> opcode-macro/src/lib.rs:132:5
[INFO] [stderr]     |
[INFO] [stderr] 132 |     separator: Token![:],
[INFO] [stderr]     |     ^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(dead_code)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: field is never read: `keyword`
[INFO] [stderr]    --> opcode-macro/src/lib.rs:148:9
[INFO] [stderr]     |
[INFO] [stderr] 148 |         keyword: kw::ReadOnly
[INFO] [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: field is never read: `keyword`
[INFO] [stderr]    --> opcode-macro/src/lib.rs:151:9
[INFO] [stderr]     |
[INFO] [stderr] 151 |         keyword: kw::Writable
[INFO] [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: field is never read: `separator`
[INFO] [stderr]    --> opcode-macro/src/lib.rs:175:9
[INFO] [stderr]     |
[INFO] [stderr] 175 |         separator: Token![:],
[INFO] [stderr]     |         ^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: field is never read: `separator`
[INFO] [stderr]    --> opcode-macro/src/lib.rs:183:9
[INFO] [stderr]     |
[INFO] [stderr] 183 |         separator: Token![:],
[INFO] [stderr]     |         ^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: `opcode-macro` (lib) generated 5 warnings
[INFO] [stderr]     Finished test [unoptimized + debuginfo] target(s) in 0.02s
[INFO] [stderr]      Running unittests (/opt/rustwide/target/debug/deps/advent_of_code_2019-c5188b132ed4f46a)
[INFO] [stdout] 
[INFO] [stdout] running 16 tests
[INFO] [stdout] test intcode::tests::test_equals_with_immediate_mode ... ok
[INFO] [stdout] test intcode::tests::test_example ... ok
[INFO] [stdout] test intcode::tests::test_equals_with_position_mode ... ok
[INFO] [stdout] test intcode::tests::test_add ... ok
[INFO] [stdout] test intcode::tests::test_input_output ... ok
[INFO] [stdout] test intcode::tests::test_jumps_with_immediate_mode ... ok
[INFO] [stdout] test intcode::tests::test_less_than_with_immediate_mode ... ok
[INFO] [stdout] test intcode::tests::test_long_example_with_jumps ... ok
[INFO] [stdout] test intcode::tests::test_output_iterator ... ok
[INFO] [stdout] test intcode::tests::test_jumps_with_position_mode ... ok
[INFO] [stdout] test intcode::tests::test_less_than_with_position_mode ... ok
[INFO] [stdout] test intcode::tests::test_negatives ... ok
[INFO] [stdout] test intcode::tests::test_overriding_future_instructions ... ok
[INFO] [stdout] test intcode::tests::test_multiply_1 ... ok
[INFO] [stdout] test intcode::tests::test_parameter_modes ... ok
[INFO] [stdout] test intcode::tests::test_multiply_2 ... ok
[INFO] [stdout] 
[INFO] [stdout] test result: ok. 16 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.02s
[INFO] [stdout] 
[INFO] [stderr]      Running unittests (/opt/rustwide/target/debug/deps/advent_of_code_2019-bcd6f88973c261cf)
[INFO] [stdout] 
[INFO] [stdout] running 0 tests
[INFO] [stdout] 
[INFO] [stdout] test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
[INFO] [stdout] 
[INFO] [stderr]    Doc-tests advent_of_code_2019
[INFO] [stdout] pub enum OpCode
[INFO] [stdout] {
[INFO] [stdout]     Add, Multiply, Input, Output, JumpIfTrue, JumpIfFalse, LessThan, Equals,
[INFO] [stdout]     End
[INFO] [stdout] } impl OpCode
[INFO] [stdout] {
[INFO] [stdout]     fn
[INFO] [stdout]     get_current_instruction(memory : & [EmulatorMemoryType],
[INFO] [stdout]     instruction_pointer : usize) -> Result <
[INFO] [stdout]     (OpCode, impl Iterator < Item = Result < ParameterMode, EmulatorError >>),
[INFO] [stdout]     EmulatorError >
[INFO] [stdout]     {
[INFO] [stdout]         let instruction_value = *
[INFO] [stdout]         memory.get(instruction_pointer).ok_or(EmulatorError ::
[INFO] [stdout]         InstructionPointerOutOfBounds { position : instruction_pointer, }) ? ;
[INFO] [stdout]         let instruction = match(instruction_value % 100)
[INFO] [stdout]         {
[INFO] [stdout]             1 => Ok(OpCode :: Add), 2 => Ok(OpCode :: Multiply), 3 =>
[INFO] [stdout]             Ok(OpCode :: Input), 4 => Ok(OpCode :: Output), 5 =>
[INFO] [stdout]             Ok(OpCode :: JumpIfTrue), 6 => Ok(OpCode :: JumpIfFalse), 7 =>
[INFO] [stdout]             Ok(OpCode :: LessThan), 8 => Ok(OpCode :: Equals), 99 =>
[INFO] [stdout]             Ok(OpCode :: End), _ =>
[INFO] [stdout]             Err(EmulatorError :: InvalidInstruction
[INFO] [stdout]             {
[INFO] [stdout]                 value_found : instruction_value, position :
[INFO] [stdout]                 instruction_pointer
[INFO] [stdout]             })
[INFO] [stdout]         } ? ; let parameter_mode_iterator =
[INFO] [stdout]         {
[INFO] [stdout]             let mut parameter_mode_digits = instruction_value / 100 ; std ::
[INFO] [stdout]             iter ::
[INFO] [stdout]             from_fn(move ||
[INFO] [stdout]             {
[INFO] [stdout]                 let parameter_mode_digit = parameter_mode_digits % 10 ; let
[INFO] [stdout]                 result = match parameter_mode_digit
[INFO] [stdout]                 {
[INFO] [stdout]                     0 => Ok(ParameterMode :: Position), 1 =>
[INFO] [stdout]                     Ok(ParameterMode :: Immediate), _ =>
[INFO] [stdout]                     Err(EmulatorError :: InvalidParameterMode
[INFO] [stdout]                     {
[INFO] [stdout]                         value_found : parameter_mode_digit, position :
[INFO] [stdout]                         instruction_pointer
[INFO] [stdout]                     }),
[INFO] [stdout]                 } ; parameter_mode_digits /= 10 ; Some(result)
[INFO] [stdout]             })
[INFO] [stdout]         } ; Ok((instruction, parameter_mode_iterator))
[INFO] [stdout]     } fn to_opcode(& self) -> EmulatorMemoryType
[INFO] [stdout]     {
[INFO] [stdout]         match self
[INFO] [stdout]         {
[INFO] [stdout]             OpCode :: Add => 1, OpCode :: Multiply => 2, OpCode :: Input => 3,
[INFO] [stdout]             OpCode :: Output => 4, OpCode :: JumpIfTrue => 5, OpCode ::
[INFO] [stdout]             JumpIfFalse => 6, OpCode :: LessThan => 7, OpCode :: Equals => 8,
[INFO] [stdout]             OpCode :: End => 99,
[INFO] [stdout]         }
[INFO] [stdout]     } fn
[INFO] [stdout]     handle_add(addend1 : EmulatorMemoryType, addend2 : EmulatorMemoryType,
[INFO] [stdout]     dest : & mut EmulatorMemoryType) -> Result < (), EmulatorError >
[INFO] [stdout]     { Ok({ * dest = addend1 + addend2 ; }) } fn
[INFO] [stdout]     handle_multiply(factor1 : EmulatorMemoryType, factor2 :
[INFO] [stdout]     EmulatorMemoryType, dest : & mut EmulatorMemoryType) -> Result < (),
[INFO] [stdout]     EmulatorError > { Ok({ * dest = factor1 * factor2 ; }) } fn handle_input <
[INFO] [stdout]     I : Iterator < Item = Result < EmulatorMemoryType, EmulatorError >> >
[INFO] [stdout]     (input_iter : & mut I, dest : & mut EmulatorMemoryType) -> Result < (),
[INFO] [stdout]     EmulatorError >
[INFO] [stdout]     {
[INFO] [stdout]         Ok({
[INFO] [stdout]             * dest =
[INFO] [stdout]             input_iter.next().ok_or(EmulatorError :: InputNonExistent) ? ? ;
[INFO] [stdout]         })
[INFO] [stdout]     } fn handle_output(value : EmulatorMemoryType) -> Result <
[INFO] [stdout]     EmulatorMemoryType, EmulatorError > { Ok({ value }) } fn
[INFO] [stdout]     handle_jumpiftrue(new_instruction_pointer : & mut Option <
[INFO] [stdout]     EmulatorMemoryType >, value : EmulatorMemoryType, new_address :
[INFO] [stdout]     EmulatorMemoryType) -> Result < (), EmulatorError >
[INFO] [stdout]     {
[INFO] [stdout]         Ok({
[INFO] [stdout]             if value != 0 { * new_instruction_pointer = Some(new_address) ; }
[INFO] [stdout]         })
[INFO] [stdout]     } fn
[INFO] [stdout]     handle_jumpiffalse(new_instruction_pointer : & mut Option <
[INFO] [stdout]     EmulatorMemoryType >, value : EmulatorMemoryType, new_address :
[INFO] [stdout]     EmulatorMemoryType) -> Result < (), EmulatorError >
[INFO] [stdout]     {
[INFO] [stdout]         Ok({
[INFO] [stdout]             if value == 0 { * new_instruction_pointer = Some(new_address) ; }
[INFO] [stdout]         })
[INFO] [stdout]     } fn
[INFO] [stdout]     handle_lessthan(left_side : EmulatorMemoryType, right_side :
[INFO] [stdout]     EmulatorMemoryType, dest : & mut EmulatorMemoryType) -> Result < (),
[INFO] [stdout]     EmulatorError >
[INFO] [stdout]     { Ok({ * dest = if left_side < right_side { 1 } else { 0 } ; }) } fn
[INFO] [stdout]     handle_equals(left_side : EmulatorMemoryType, right_side :
[INFO] [stdout]     EmulatorMemoryType, dest : & mut EmulatorMemoryType) -> Result < (),
[INFO] [stdout]     EmulatorError >
[INFO] [stdout]     { Ok({ * dest = if left_side == right_side { 1 } else { 0 } ; }) } fn
[INFO] [stdout]     handle_end() -> Result < (), EmulatorError > { Ok({}) } fn run < I :
[INFO] [stdout]     Iterator < Item = Result < EmulatorMemoryType, EmulatorError >> >
[INFO] [stdout]     (memory : & mut [EmulatorMemoryType], instruction_pointer : usize,
[INFO] [stdout]     input_iter : & mut I) -> Result <
[INFO] [stdout]     (Option < usize >, Option < EmulatorMemoryType >), EmulatorError >
[INFO] [stdout]     {
[INFO] [stdout]         let(instruction, mut parameter_mode_iterator) = OpCode ::
[INFO] [stdout]         get_current_instruction(memory, instruction_pointer) ? ; let mut
[INFO] [stdout]         new_instruction_pointer = None ; match instruction
[INFO] [stdout]         {
[INFO] [stdout]             OpCode :: Add =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 3usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 3usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 3usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let addend1 : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let addend2 : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let dest : & mut EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 2usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ;
[INFO] [stdout]                         memory.get_mut(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     {
[INFO] [stdout]                         return
[INFO] [stdout]                         Err(EmulatorError :: UnexpectedParameterModeForWritable
[INFO] [stdout]                         {
[INFO] [stdout]                             value_found : 1, position : instruction_pointer + 2usize +
[INFO] [stdout]                             1,
[INFO] [stdout]                         })
[INFO] [stdout]                     }
[INFO] [stdout]                 } ; let _ : () = OpCode :: handle_add(addend1, addend2, dest)
[INFO] [stdout]                 ? ; Ok((Some(instruction_pointer + 4usize), None))
[INFO] [stdout]             }, OpCode :: Multiply =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 3usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 3usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 3usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let factor1 : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let factor2 : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let dest : & mut EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 2usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ;
[INFO] [stdout]                         memory.get_mut(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     {
[INFO] [stdout]                         return
[INFO] [stdout]                         Err(EmulatorError :: UnexpectedParameterModeForWritable
[INFO] [stdout]                         {
[INFO] [stdout]                             value_found : 1, position : instruction_pointer + 2usize +
[INFO] [stdout]                             1,
[INFO] [stdout]                         })
[INFO] [stdout]                     }
[INFO] [stdout]                 } ; let _ : () = OpCode ::
[INFO] [stdout]                 handle_multiply(factor1, factor2, dest) ? ;
[INFO] [stdout]                 Ok((Some(instruction_pointer + 4usize), None))
[INFO] [stdout]             }, OpCode :: Input =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 1usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 1usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 1usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let dest : & mut EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ;
[INFO] [stdout]                         memory.get_mut(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     {
[INFO] [stdout]                         return
[INFO] [stdout]                         Err(EmulatorError :: UnexpectedParameterModeForWritable
[INFO] [stdout]                         {
[INFO] [stdout]                             value_found : 1, position : instruction_pointer + 0usize +
[INFO] [stdout]                             1,
[INFO] [stdout]                         })
[INFO] [stdout]                     }
[INFO] [stdout]                 } ; let _ : () = OpCode :: handle_input(input_iter, dest) ? ;
[INFO] [stdout]                 Ok((Some(instruction_pointer + 2usize), None))
[INFO] [stdout]             }, OpCode :: Output =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 1usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 1usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 1usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let value : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let output : EmulatorMemoryType = OpCode ::
[INFO] [stdout]                 handle_output(value) ? ;
[INFO] [stdout]                 Ok((Some(instruction_pointer + 2usize), Some(output)))
[INFO] [stdout]             }, OpCode :: JumpIfTrue =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 2usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 2usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 2usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let value : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let new_address : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let _ : () = OpCode ::
[INFO] [stdout]                 handle_jumpiftrue(& mut new_instruction_pointer, value,
[INFO] [stdout]                 new_address) ? ;
[INFO] [stdout]                 Ok((Some(new_instruction_pointer.map(| value | std :: convert
[INFO] [stdout]                 :: TryInto :: < usize > ::
[INFO] [stdout]                 try_into(value).or(Err(EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                 {
[INFO] [stdout]                     value_found : value, position : 0
[INFO] [stdout]                 }))).unwrap_or(Ok(instruction_pointer + 3usize)) ?), None))
[INFO] [stdout]             }, OpCode :: JumpIfFalse =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 2usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 2usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 2usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let value : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let new_address : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let _ : () = OpCode ::
[INFO] [stdout]                 handle_jumpiffalse(& mut new_instruction_pointer, value,
[INFO] [stdout]                 new_address) ? ;
[INFO] [stdout]                 Ok((Some(new_instruction_pointer.map(| value | std :: convert
[INFO] [stdout]                 :: TryInto :: < usize > ::
[INFO] [stdout]                 try_into(value).or(Err(EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                 {
[INFO] [stdout]                     value_found : value, position : 0
[INFO] [stdout]                 }))).unwrap_or(Ok(instruction_pointer + 3usize)) ?), None))
[INFO] [stdout]             }, OpCode :: LessThan =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 3usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 3usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 3usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let left_side : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let right_side : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let dest : & mut EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 2usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ;
[INFO] [stdout]                         memory.get_mut(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     {
[INFO] [stdout]                         return
[INFO] [stdout]                         Err(EmulatorError :: UnexpectedParameterModeForWritable
[INFO] [stdout]                         {
[INFO] [stdout]                             value_found : 1, position : instruction_pointer + 2usize +
[INFO] [stdout]                             1,
[INFO] [stdout]                         })
[INFO] [stdout]                     }
[INFO] [stdout]                 } ; let _ : () = OpCode ::
[INFO] [stdout]                 handle_lessthan(left_side, right_side, dest) ? ;
[INFO] [stdout]                 Ok((Some(instruction_pointer + 4usize), None))
[INFO] [stdout]             }, OpCode :: Equals =>
[INFO] [stdout]             {
[INFO] [stdout]                 if instruction_pointer + 1 + 3usize >= memory.len()
[INFO] [stdout]                 {
[INFO] [stdout]                     return
[INFO] [stdout]                     Err(EmulatorError :: NotEnoughParametersForInstruction
[INFO] [stdout]                     {
[INFO] [stdout]                         instruction : instruction.to_opcode(), expected : 3usize,
[INFO] [stdout]                         found : instruction_pointer + 1 + 3usize - memory.len(),
[INFO] [stdout]                     })
[INFO] [stdout]                 } let left_side : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 0usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 0usize + 1] }
[INFO] [stdout]                 } ; let right_side : EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 1usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ; *
[INFO] [stdout]                         memory.get(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     { memory [instruction_pointer + 1usize + 1] }
[INFO] [stdout]                 } ; let dest : & mut EmulatorMemoryType = match
[INFO] [stdout]                 parameter_mode_iterator.next().unwrap() ?
[INFO] [stdout]                 {
[INFO] [stdout]                     ParameterMode :: Position =>
[INFO] [stdout]                     {
[INFO] [stdout]                         let parameter_location = instruction_pointer + 2usize + 1 ;
[INFO] [stdout]                         let address = memory [parameter_location] ; let error =
[INFO] [stdout]                         EmulatorError :: InvalidMemoryLocation
[INFO] [stdout]                         { value_found : address, position : parameter_location, } ;
[INFO] [stdout]                         let address_converted = std :: convert :: TryInto :: < usize
[INFO] [stdout]                         > :: try_into(address).or(Err(error)) ? ;
[INFO] [stdout]                         memory.get_mut(address_converted).ok_or(error) ?
[INFO] [stdout]                     }, ParameterMode :: Immediate =>
[INFO] [stdout]                     {
[INFO] [stdout]                         return
[INFO] [stdout]                         Err(EmulatorError :: UnexpectedParameterModeForWritable
[INFO] [stdout]                         {
[INFO] [stdout]                             value_found : 1, position : instruction_pointer + 2usize +
[INFO] [stdout]                             1,
[INFO] [stdout]                         })
[INFO] [stdout]                     }
[INFO] [stdout]                 } ; let _ : () = OpCode ::
[INFO] [stdout]                 handle_equals(left_side, right_side, dest) ? ;
[INFO] [stdout]                 Ok((Some(instruction_pointer + 4usize), None))
[INFO] [stdout]             }, OpCode :: End =>
[INFO] [stdout]             { let _ : () = OpCode :: handle_end() ? ; Ok((None, None)) }
[INFO] [stdout]         }
[INFO] [stdout]     }
[INFO] [stdout] }
[INFO] [stdout] 
[INFO] [stdout] running 0 tests
[INFO] [stdout] 
[INFO] [stdout] test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
[INFO] [stdout] 
[INFO] running `Command { std: "docker" "inspect" "7ddcfe11f3bb6bf91252f8464938edfc7a9fafbe6468663ff6ccd466bcba6b47", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "7ddcfe11f3bb6bf91252f8464938edfc7a9fafbe6468663ff6ccd466bcba6b47", kill_on_drop: false }`
[INFO] [stdout] 7ddcfe11f3bb6bf91252f8464938edfc7a9fafbe6468663ff6ccd466bcba6b47