path: root/arc/.traces/read-move-legal

===: main
c{0: 0 (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal) (capacity))) -- nil
c{0: 1 (((stdin channel-address)) <- ((init-channel)) ((1 literal))) -- nil
c{0: 2 (((r integer) (routine)) <- ((fork)) ((read-move fn)) ((nil literal) (globals)) ((2000 literal) (limit)) ((stdin channel-address))) -- nil
c{0: 3 (((c character)) <- ((copy)) ((a literal))) -- nil
c{0: 4 (((x tagged-value)) <- ((save-type)) ((c character))) -- nil
c{0: 5 (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value))) -- nil
c{0: 6 (((c character)) <- ((copy)) ((2 literal))) -- nil
c{0: 7 (((x tagged-value)) <- ((save-type)) ((c character))) -- nil
c{0: 8 (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value))) -- nil
c{0: 9 (((c character)) <- ((copy)) ((- literal))) -- nil
c{0: 10 (((x tagged-value)) <- ((save-type)) ((c character))) -- nil
c{0: 11 (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value))) -- nil
c{0: 12 (((c character)) <- ((copy)) ((a literal))) -- nil
c{0: 13 (((x tagged-value)) <- ((save-type)) ((c character))) -- nil
c{0: 14 (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value))) -- nil
c{0: 15 (((c character)) <- ((copy)) ((4 literal))) -- nil
c{0: 16 (((x tagged-value)) <- ((save-type)) ((c character))) -- nil
c{0: 17 (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value))) -- nil
c{0: 18 (((c character)) <- ((copy)) ((
 literal))) -- nil
c{0: 19 (((x tagged-value)) <- ((save-type)) ((c character))) -- nil
c{0: 20 (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value))) -- nil
c{0: 21 (((sleep)) ((until-routine-done literal)) ((r integer) (routine))) -- nil
c{1: 0 ✓ (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal) (capacity)))
c{1: 1 ✓ (((stdin channel-address)) <- ((init-channel)) ((1 literal)))
c{1: 2 ✓ (((r integer) (routine)) <- ((fork)) ((read-move fn)) ((nil literal) (globals)) ((2000 literal) (limit)) ((stdin channel-address)))
c{1: 3 ✓ (((c character)) <- ((copy)) ((a literal)))
c{1: 4 ✓ (((x tagged-value)) <- ((save-type)) ((c character)))
c{1: 5 ✓ (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value)))
c{1: 6 ✓ (((c character)) <- ((copy)) ((2 literal)))
c{1: 7 ✓ (((x tagged-value)) <- ((save-type)) ((c character)))
c{1: 8 ✓ (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value)))
c{1: 9 ✓ (((c character)) <- ((copy)) ((- literal)))
c{1: 10 ✓ (((x tagged-value)) <- ((save-type)) ((c character)))
c{1: 11 ✓ (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value)))
c{1: 12 ✓ (((c character)) <- ((copy)) ((a literal)))
c{1: 13 ✓ (((x tagged-value)) <- ((save-type)) ((c character)))
c{1: 14 ✓ (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value)))
c{1: 15 ✓ (((c character)) <- ((copy)) ((4 literal)))
c{1: 16 ✓ (((x tagged-value)) <- ((save-type)) ((c character)))
c{1: 17 ✓ (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value)))
c{1: 18 ✓ (((c character)) <- ((copy)) ((
 literal)))
c{1: 19 ✓ (((x tagged-value)) <- ((save-type)) ((c character)))
c{1: 20 ✓ (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value)))
c{1: 21 ✓ (((sleep)) ((until-routine-done literal)) ((r integer) (routine)))
cn0: convert-names in main
cn0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal) (capacity))) nil nil
cn0: checking arg ((space literal))
cn0: checking arg ((30 literal) (capacity))
cn0: checking oarg ((default-space space-address))
maybe-add: ((default-space space-address))
cn0: (((stdin channel-address)) <- ((init-channel)) ((1 literal))) nil nil
cn0: checking arg ((1 literal))
cn0: checking oarg ((stdin channel-address))
maybe-add: ((stdin channel-address))
cn0: location for oarg ((stdin channel-address)): 1
cn0: (((r integer) (routine)) <- ((fork)) ((read-move fn)) ((nil literal) (globals)) ((2000 literal) (limit)) ((stdin channel-address))) ((stdin 1)) nil
cn0: checking arg ((read-move fn))
cn0: checking arg ((nil literal) (globals))
cn0: checking arg ((2000 literal) (limit))
cn0: checking arg ((stdin channel-address))
maybe-add: ((stdin channel-address))
cn0: checking oarg ((r integer) (routine))
maybe-add: ((r integer) (routine))
cn0: location for oarg ((r integer) (routine)): 2
cn0: (((c character)) <- ((copy)) ((a literal))) ((r 2) (stdin 1)) nil
cn0: checking arg ((a literal))
cn0: checking oarg ((c character))
maybe-add: ((c character))
cn0: location for oarg ((c character)): 3
cn0: (((x tagged-value)) <- ((save-type)) ((c character))) ((c 3) (r 2) (stdin 1)) nil
cn0: checking arg ((c character))
maybe-add: ((c character))
cn0: checking oarg ((x tagged-value))
maybe-add: ((x tagged-value))
cn0: location for oarg ((x tagged-value)): 4
cn0: (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value))) ((c 3) (r 2) (stdin 1) (x 4)) nil
cn0: checking arg ((stdin channel-address))
maybe-add: ((stdin channel-address))
cn0: checking arg ((x tagged-value))
maybe-add: ((x tagged-value))
cn0: checking oarg ((stdin channel-address) (deref))
maybe-add: ((stdin channel-address) (deref))
cn0: (((c character)) <- ((copy)) ((2 literal))) ((c 3) (r 2) (stdin 1) (x 4)) nil
cn0: checking arg ((2 literal))
cn0: checking oarg ((c character))
maybe-add: ((c character))
cn0: (((x tagged-value)) <- ((save-type)) ((c character))) ((c 3) (r 2) (stdin 1) (x 4)) nil
cn0: checking arg ((c character))
maybe-add: ((c character))
cn0: checking oarg ((x tagged-value))
maybe-add: ((x tagged-value))
cn0: (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value))) ((c 3) (r 2) (stdin 1) (x 4)) nil
cn0: checking arg ((stdin channel-address))
maybe-add: ((stdin channel-address))
cn0: checking arg ((x tagged-value))
maybe-add: ((x tagged-value))
cn0: checking oarg ((stdin channel-address) (deref))
maybe-add: ((stdin channel-address) (deref))
cn0: (((c character)) <- ((copy)) ((- literal))) ((c 3) (r 2) (stdin 1) (x 4)) nil
cn0: checking arg ((- literal))
cn0: checking oarg ((c character))
maybe-add: ((c character))
cn0: (((x tagged-value)) <- ((save-type)) ((c character))) ((c 3) (r 2) (stdin 1) (x 4)) nil
cn0: checking arg ((c character))
maybe-add: ((c character))
cn0: checking oarg ((x tagged-value))
maybe-add: ((x tagged-value))
cn0: (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value))) ((c 3) (r 2) (stdin 1) (x 4)) nil
cn0: checking arg ((stdin channel-address))
maybe-add: ((stdin channel-address))
cn0: checking arg ((x tagged-value))
maybe-add: ((x tagged-value))
cn0: checking oarg ((stdin channel-address) (deref))
maybe-add: ((stdin channel-address) (deref))
cn0: (((c character)) <- ((copy)) ((a literal))) ((c 3) (r 2) (stdin 1) (x 4)) nil
cn0: checking arg ((a literal))
cn0: checking oarg ((c character))
maybe-add: ((c character))
cn0: (((x tagged-value)) <- ((save-type)) ((c character))) ((c 3) (r 2) (stdin 1) (x 4)) nil
cn0: checking arg ((c character))
maybe-add: ((c character))
cn0: checking oarg ((x tagged-value))
maybe-add: ((x tagged-value))
cn0: (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value))) ((c 3) (r 2) (stdin 1) (x 4)) nil
cn0: checking arg ((stdin channel-address))
maybe-add: ((stdin channel-address))
cn0: checking arg ((x tagged-value))
maybe-add: ((x tagged-value))
cn0: checking oarg ((stdin channel-address) (deref))
maybe-add: ((stdin channel-address) (deref))
cn0: (((c character)) <- ((copy)) ((4 literal))) ((c 3) (r 2) (stdin 1) (x 4)) nil
cn0: checking arg ((4 literal))
cn0: checking oarg ((c character))
maybe-add: ((c character))
cn0: (((x tagged-value)) <- ((save-type)) ((c character))) ((c 3) (r 2) (stdin 1) (x 4)) nil
cn0: checking arg ((c character))
maybe-add: ((c character))
cn0: checking oarg ((x tagged-value))
maybe-add: ((x tagged-value))
cn0: (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value))) ((c 3) (r 2) (stdin 1) (x 4)) nil
cn0: checking arg ((stdin channel-address))
maybe-add: ((stdin channel-address))
cn0: checking arg ((x tagged-value))
maybe-add: ((x tagged-value))
cn0: checking oarg ((stdin channel-address) (deref))
maybe-add: ((stdin channel-address) (deref))
cn0: (((c character)) <- ((copy)) ((
 literal))) ((c 3) (r 2) (stdin 1) (x 4)) nil
cn0: checking arg ((
 literal))
cn0: checking oarg ((c character))
maybe-add: ((c character))
cn0: (((x tagged-value)) <- ((save-type)) ((c character))) ((c 3) (r 2) (stdin 1) (x 4)) nil
cn0: checking arg ((c character))
maybe-add: ((c character))
cn0: checking oarg ((x tagged-value))
maybe-add: ((x tagged-value))
cn0: (((stdin channel-address) (deref)) <- ((write)) ((stdin channel-address)) ((x tagged-value))) ((c 3) (r 2) (stdin 1) (x 4)) nil
cn0: checking arg ((stdin channel-address))
maybe-add: ((stdin channel-address))
cn0: checking arg ((x tagged-value))
maybe-add: ((x tagged-value))
cn0: checking oarg ((stdin channel-address) (deref))
maybe-add: ((stdin channel-address) (deref))
cn0: (((sleep)) ((until-routine-done literal)) ((r integer) (routine))) ((c 3) (r 2) (stdin 1) (x 4)) nil
cn0: checking arg ((until-routine-done literal))
cn0: checking arg ((r integer) (routine))
maybe-add: ((r integer) (routine))
cn1: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal) (capacity)))
cn1: (((1 channel-address)) <- ((init-channel)) ((1 literal)))
cn1: (((2 integer) (routine)) <- ((fork)) ((read-move fn)) ((nil literal) (globals)) ((2000 literal) (limit)) ((1 channel-address)))
cn1: (((3 character)) <- ((copy)) ((a literal)))
cn1: (((4 tagged-value)) <- ((save-type)) ((3 character)))
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((4 tagged-value)))
cn1: (((3 character)) <- ((copy)) ((2 literal)))
cn1: (((4 tagged-value)) <- ((save-type)) ((3 character)))
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((4 tagged-value)))
cn1: (((3 character)) <- ((copy)) ((- literal)))
cn1: (((4 tagged-value)) <- ((save-type)) ((3 character)))
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((4 tagged-value)))
cn1: (((3 character)) <- ((copy)) ((a literal)))
cn1: (((4 tagged-value)) <- ((save-type)) ((3 character)))
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((4 tagged-value)))
cn1: (((3 character)) <- ((copy)) ((4 literal)))
cn1: (((4 tagged-value)) <- ((save-type)) ((3 character)))
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((4 tagged-value)))
cn1: (((3 character)) <- ((copy)) ((
 literal)))
cn1: (((4 tagged-value)) <- ((save-type)) ((3 character)))
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((4 tagged-value)))
cn1: (((sleep)) ((until-routine-done literal)) ((2 integer) (routine)))
schedule: main
run: main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal) (capacity)))
run: main 0: 1000 => ((default-space space-address))
run: main 1: (((1 channel-address)) <- ((init-channel)) ((1 literal)))
run: init-channel/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: init-channel/main 0: 1031 => ((default-space space-address))
run: init-channel/main 1: (((1 channel-address)) <- ((new)) ((channel literal)))
run: init-channel/main 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 1033 <= 1062
run: init-channel/main 2: (((2 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
run: init-channel/main 2: 1062 => ((2 integer-address))
mem: ((2 integer-address)): 1034 <= 1062
run: init-channel/main 3: (((2 integer-address) (deref)) <- ((copy)) ((0 literal)))
run: init-channel/main 3: 0 => ((2 integer-address) (deref))
mem: ((2 integer-address) (deref)): 1062 <= 0
run: init-channel/main 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
run: init-channel/main 4: 1063 => ((3 integer-address))
mem: ((3 integer-address)): 1035 <= 1063
run: init-channel/main 5: (((3 integer-address) (deref)) <- ((copy)) ((0 literal)))
run: init-channel/main 5: 0 => ((3 integer-address) (deref))
mem: ((3 integer-address) (deref)): 1063 <= 0
run: init-channel/main 6: (((4 integer)) <- ((next-input)))
arg: nil 0 (1)
run: init-channel/main 6: 1 => ((4 integer))
mem: ((4 integer)): 1036 <= 1
run: init-channel/main 7: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
mem: ((4 integer)) => 1
run: init-channel/main 7: 2 => ((4 integer))
mem: ((4 integer)): 1036 <= 2
run: init-channel/main 8: (((5 tagged-value-array-address-address)) <- ((get-address)) ((1 channel-address) (deref)) ((2 offset)))
run: init-channel/main 8: 1064 => ((5 tagged-value-array-address-address))
mem: ((5 tagged-value-array-address-address)): 1037 <= 1064
run: init-channel/main 9: (((5 tagged-value-array-address-address) (deref)) <- ((new)) ((tagged-value-array literal)) ((4 integer)))
mem: ((4 integer)) => 2
run: init-channel/main 9: 1065 => ((5 tagged-value-array-address-address) (deref))
mem: ((5 tagged-value-array-address-address) (deref)): 1064 <= 1065
run: init-channel/main 10: (((reply)) ((1 channel-address)))
mem: ((1 channel-address)) => 1062
run: main 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 1002 <= 1062
run: main 2: (((2 integer) (routine)) <- ((fork)) ((read-move fn)) ((nil literal) (globals)) ((2000 literal) (limit)) ((1 channel-address)))
mem: ((1 channel-address)) => 1062
run: main 2: 1 => ((2 integer) (routine))
mem: ((2 integer) (routine)): 1003 <= 1
run: main 3: (((3 character)) <- ((copy)) ((a literal)))
run: main 3: #\a => ((3 character))
mem: ((3 character)): 1004 <= #\a
run: main 4: (((4 tagged-value)) <- ((save-type)) ((3 character)))
mem: ((3 character)) => a
run: main 4: #(tagged record (character #\a)) => ((4 tagged-value))
mem: ((4 tagged-value)): 1005 <= character
mem: ((4 tagged-value)): 1006 <= #\a
run: main 5: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((4 tagged-value)))
mem: ((1 channel-address)) => 1062
mem: ((4 tagged-value)) => #(tagged record (character a . nil))
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: write/main 0: 1070 => ((default-space space-address))
run: write/main 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062 #(tagged record (character #\a . nil)))
run: write/main 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 1072 <= 1062
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
arg: nil 1 (1062 #(tagged record (character #\a . nil)))
run: write/main 2: #(tagged record (character #\a . nil)) => ((2 tagged-value))
mem: ((2 tagged-value)): 1073 <= character
mem: ((2 tagged-value)): 1074 <= #\a
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1065 . nil))
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: full?/write/main 0: 1101 => ((default-space space-address))
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (0 0 1065 . nil)))
run: full?/write/main 1: #(tagged record (0 0 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 1103 <= 0
mem: ((1 channel)): 1104 <= 0
mem: ((1 channel)): 1105 <= 1065
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
mem: ((1104 integer) (raw)) => 0
run: full?/write/main 2: 0 => ((4 integer))
mem: ((4 integer)): 1106 <= 0
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
mem: ((4 integer)) => 0
run: full?/write/main 3: 1 => ((4 integer))
mem: ((4 integer)): 1106 <= 1
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
mem: ((1 channel)) => #(tagged record (0 0 1065 . nil))
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: capacity/full?/write/main 0: 1132 => ((default-space space-address))
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (0 0 1065 . nil)))
run: capacity/full?/write/main 1: #(tagged record (0 0 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 1134 <= 0
mem: ((1 channel)): 1135 <= 0
mem: ((1 channel)): 1136 <= 1065
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
mem: ((1136 tagged-value-array-address) (raw)) => 1065
run: capacity/full?/write/main 2: 1065 => ((4 tagged-value-array-address))
mem: ((4 tagged-value-array-address)): 1137 <= 1065
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
array-len: ((4 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: capacity/full?/write/main 3: 2 => ((5 integer))
mem: ((5 integer)): 1138 <= 2
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
mem: ((5 integer)) => 2
run: full?/write/main 4: 2 => ((5 integer))
mem: ((5 integer)): 1107 <= 2
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
mem: ((4 integer)) => 1
mem: ((5 integer)) => 2
run: full?/write/main 5: t => ((6 boolean))
mem: ((6 boolean)): 1108 <= t
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
mem: ((6 boolean)) => t
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
mem: ((1103 integer) (raw)) => 0
run: full?/write/main 8: 0 => ((7 integer))
mem: ((7 integer)): 1109 <= 0
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
mem: ((7 integer)) => 0
mem: ((4 integer)) => 1
run: full?/write/main 9: nil => ((8 boolean))
mem: ((8 boolean)): 1110 <= nil
run: full?/write/main 10: (((reply)) ((8 boolean)))
mem: ((8 boolean)) => nil
run: write/main 3: nil => ((4 boolean))
mem: ((4 boolean)): 1075 <= nil
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
mem: ((4 boolean)) => nil
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
mem: ((1064 tagged-value-array-address) (raw)) => 1065
run: write/main 7: 1065 => ((6 tagged-value-array-address))
mem: ((6 tagged-value-array-address)): 1077 <= 1065
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
run: write/main 8: 1063 => ((7 integer-address))
mem: ((7 integer-address)): 1078 <= 1063
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
mem: ((7 integer-address) (deref)) => 0
array-len: ((1065 tagged-value-array) (raw))
mem: ((1065 integer) (raw)) => 2
run: write/main 9: 1066 => ((8 tagged-value-address))
mem: ((8 tagged-value-address)): 1079 <= 1066
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
mem: ((2 tagged-value)) => #(tagged record (character a . nil))
run: write/main 10: #(tagged record (character #\a . nil)) => ((8 tagged-value-address) (deref))
mem: ((8 tagged-value-address) (deref)): 1066 <= character
mem: ((8 tagged-value-address) (deref)): 1067 <= #\a
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
mem: ((7 integer-address) (deref)) => 0
run: write/main 11: 1 => ((7 integer-address) (deref))
mem: ((7 integer-address) (deref)): 1063 <= 1
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
array-len: ((6 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: write/main 12: 2 => ((9 integer))
mem: ((9 integer)): 1080 <= 2
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
mem: ((7 integer-address) (deref)) => 1
mem: ((9 integer)) => 2
run: write/main 13: t => ((10 boolean))
mem: ((10 boolean)): 1081 <= t
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
mem: ((10 boolean)) => t
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 1 1065 . nil))
run: main 5: #(tagged record (0 1 1065 . nil)) => ((1 channel-address) (deref))
mem: ((1 channel-address) (deref)): 1062 <= 0
mem: ((1 channel-address) (deref)): 1063 <= 1
mem: ((1 channel-address) (deref)): 1064 <= 1065
run: main 6: (((3 character)) <- ((copy)) ((2 literal)))
run: main 6: #\2 => ((3 character))
mem: ((3 character)): 1004 <= #\2
run: main 7: (((4 tagged-value)) <- ((save-type)) ((3 character)))
mem: ((3 character)) => 2
run: main 7: #(tagged record (character #\2)) => ((4 tagged-value))
mem: ((4 tagged-value)): 1005 <= character
mem: ((4 tagged-value)): 1006 <= #\2
run: main 8: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((4 tagged-value)))
mem: ((1 channel-address)) => 1062
mem: ((4 tagged-value)) => #(tagged record (character 2 . nil))
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: write/main 0: 1163 => ((default-space space-address))
run: write/main 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062 #(tagged record (character #\2 . nil)))
run: write/main 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 1165 <= 1062
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
arg: nil 1 (1062 #(tagged record (character #\2 . nil)))
run: write/main 2: #(tagged record (character #\2 . nil)) => ((2 tagged-value))
mem: ((2 tagged-value)): 1166 <= character
mem: ((2 tagged-value)): 1167 <= #\2
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
mem: ((1 channel-address) (deref)) => #(tagged record (0 1 1065 . nil))
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: full?/write/main 0: 1194 => ((default-space space-address))
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (0 1 1065 . nil)))
run: full?/write/main 1: #(tagged record (0 1 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 1196 <= 0
mem: ((1 channel)): 1197 <= 1
mem: ((1 channel)): 1198 <= 1065
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
mem: ((1197 integer) (raw)) => 1
run: full?/write/main 2: 1 => ((4 integer))
mem: ((4 integer)): 1199 <= 1
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
mem: ((4 integer)) => 1
run: full?/write/main 3: 2 => ((4 integer))
mem: ((4 integer)): 1199 <= 2
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
mem: ((1 channel)) => #(tagged record (0 1 1065 . nil))
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: capacity/full?/write/main 0: 1225 => ((default-space space-address))
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (0 1 1065 . nil)))
run: capacity/full?/write/main 1: #(tagged record (0 1 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 1227 <= 0
mem: ((1 channel)): 1228 <= 1
mem: ((1 channel)): 1229 <= 1065
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
mem: ((1229 tagged-value-array-address) (raw)) => 1065
run: capacity/full?/write/main 2: 1065 => ((4 tagged-value-array-address))
mem: ((4 tagged-value-array-address)): 1230 <= 1065
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
array-len: ((4 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: capacity/full?/write/main 3: 2 => ((5 integer))
mem: ((5 integer)): 1231 <= 2
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
mem: ((5 integer)) => 2
run: full?/write/main 4: 2 => ((5 integer))
mem: ((5 integer)): 1200 <= 2
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
mem: ((4 integer)) => 2
mem: ((5 integer)) => 2
run: full?/write/main 5: nil => ((6 boolean))
mem: ((6 boolean)): 1201 <= nil
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
mem: ((6 boolean)) => nil
run: full?/write/main 7: (((4 integer)) <- ((copy)) ((0 literal)))
run: full?/write/main 7: 0 => ((4 integer))
mem: ((4 integer)): 1199 <= 0
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
mem: ((1196 integer) (raw)) => 0
run: full?/write/main 8: 0 => ((7 integer))
mem: ((7 integer)): 1202 <= 0
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
mem: ((7 integer)) => 0
mem: ((4 integer)) => 0
run: full?/write/main 9: t => ((8 boolean))
mem: ((8 boolean)): 1203 <= t
run: full?/write/main 10: (((reply)) ((8 boolean)))
mem: ((8 boolean)) => t
run: write/main 3: t => ((4 boolean))
mem: ((4 boolean)): 1168 <= t
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
mem: ((4 boolean)) => t
run: write/main 5: (((5 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
run: write/main 5: 1062 => ((5 integer-address))
mem: ((5 integer-address)): 1169 <= 1062
run: write/main 6: (((sleep)) ((until-location-changes literal)) ((5 integer-address) (deref)))
mem: ((5 integer-address) (deref)) => 0
schedule: pushing write/main to sleep queue
schedule: read-move
run: read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: read-move 0: 101000 => ((default-space space-address))
run: read-move 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062)
run: read-move 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 101002 <= 1062
run: read-move 2: (((2 integer)) <- ((read-file)) ((1 channel-address)))
mem: ((1 channel-address)) => 1062
run: read-file/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: read-file/read-move 0: 101031 => ((default-space space-address))
run: read-file/read-move 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062)
run: read-file/read-move 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 101033 <= 1062
run: read-file/read-move 2: (((2 tagged-value)) ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
mem: ((1 channel-address)) => 1062
run: read/read-file/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: read/read-file/read-move 0: 101062 => ((default-space space-address))
run: read/read-file/read-move 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062)
run: read/read-file/read-move 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 101064 <= 1062
run: read/read-file/read-move 2: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
mem: ((1 channel-address) (deref)) => #(tagged record (0 1 1065 . nil))
run: empty?/read/read-file/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: empty?/read/read-file/read-move 0: 101093 => ((default-space space-address))
run: empty?/read/read-file/read-move 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (0 1 1065 . nil)))
run: empty?/read/read-file/read-move 1: #(tagged record (0 1 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 101095 <= 0
mem: ((1 channel)): 101096 <= 1
mem: ((1 channel)): 101097 <= 1065
run: empty?/read/read-file/read-move 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
mem: ((101095 integer) (raw)) => 0
run: empty?/read/read-file/read-move 2: 0 => ((4 integer))
mem: ((4 integer)): 101098 <= 0
run: empty?/read/read-file/read-move 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
mem: ((101096 integer) (raw)) => 1
run: empty?/read/read-file/read-move 3: 1 => ((5 integer))
mem: ((5 integer)): 101099 <= 1
run: empty?/read/read-file/read-move 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
mem: ((4 integer)) => 0
mem: ((5 integer)) => 1
run: empty?/read/read-file/read-move 4: nil => ((6 boolean))
mem: ((6 boolean)): 101100 <= nil
run: empty?/read/read-file/read-move 5: (((reply)) ((6 boolean)))
mem: ((6 boolean)) => nil
run: read/read-file/read-move 2: nil => ((2 boolean))
mem: ((2 boolean)): 101065 <= nil
run: read/read-file/read-move 3: (((jump-unless)) ((2 boolean)) ((2 offset)))
mem: ((2 boolean)) => nil
run: read/read-file/read-move 6: (((4 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
run: read/read-file/read-move 6: 1062 => ((4 integer-address))
mem: ((4 integer-address)): 101067 <= 1062
run: read/read-file/read-move 7: (((5 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
mem: ((1064 tagged-value-array-address) (raw)) => 1065
run: read/read-file/read-move 7: 1065 => ((5 tagged-value-array-address))
mem: ((5 tagged-value-array-address)): 101068 <= 1065
run: read/read-file/read-move 8: (((6 tagged-value)) <- ((index)) ((5 tagged-value-array-address) (deref)) ((4 integer-address) (deref)))
mem: ((4 integer-address) (deref)) => 0
array-len: ((1065 tagged-value-array) (raw))
mem: ((1065 integer) (raw)) => 2
mem: ((1066 tagged-value) (raw)) => #(tagged record (character a . nil))
run: read/read-file/read-move 8: #(tagged record (character #\a . nil)) => ((6 tagged-value))
mem: ((6 tagged-value)): 101069 <= character
mem: ((6 tagged-value)): 101070 <= #\a
run: read/read-file/read-move 9: (((4 integer-address) (deref)) <- ((add)) ((4 integer-address) (deref)) ((1 literal)))
mem: ((4 integer-address) (deref)) => 0
run: read/read-file/read-move 9: 1 => ((4 integer-address) (deref))
mem: ((4 integer-address) (deref)): 1062 <= 1
run: read/read-file/read-move 10: (((8 integer)) <- ((length)) ((5 tagged-value-array-address) (deref)))
array-len: ((5 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: read/read-file/read-move 10: 2 => ((8 integer))
mem: ((8 integer)): 101071 <= 2
run: read/read-file/read-move 11: (((9 boolean)) <- ((less-than)) ((4 integer-address) (deref)) ((8 integer)))
mem: ((4 integer-address) (deref)) => 1
mem: ((8 integer)) => 2
run: read/read-file/read-move 11: t => ((9 boolean))
mem: ((9 boolean)): 101072 <= t
run: read/read-file/read-move 12: (((jump-if)) ((9 boolean)) ((1 offset)))
mem: ((9 boolean)) => t
run: read/read-file/read-move 14: (((reply)) ((6 tagged-value)) ((1 channel-address) (deref) (same-as-arg 0)))
mem: ((6 tagged-value)) => #(tagged record (character a . nil))
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (1 1 1065 . nil))
run: read-file/read-move 2: #(tagged record (character #\a . nil)) => ((2 tagged-value))
mem: ((2 tagged-value)): 101034 <= character
mem: ((2 tagged-value)): 101035 <= #\a
run: read-file/read-move 2: #(tagged record (1 1 1065 . nil)) => ((1 channel-address) (deref))
mem: ((1 channel-address) (deref)): 1062 <= 1
mem: ((1 channel-address) (deref)): 1063 <= 1
mem: ((1 channel-address) (deref)): 1064 <= 1065
run: read-file/read-move 3: (((4 character)) <- ((copy)) ((a literal)))
run: read-file/read-move 3: #\a => ((4 character))
mem: ((4 character)): 101036 <= #\a
run: read-file/read-move 4: (((5 integer)) <- ((character-to-integer)) ((4 character)))
mem: ((4 character)) => a
run: read-file/read-move 4: 97 => ((5 integer))
mem: ((5 integer)): 101037 <= 97
run: read-file/read-move 5: (((6 character)) <- ((maybe-coerce)) ((2 tagged-value)) ((character literal)))
mem: ((2 tagged-value)) => #(tagged record (character a . nil))
run: maybe-coerce/read-file/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: maybe-coerce/read-file/read-move 0: 101124 => ((default-space space-address))
run: maybe-coerce/read-file/read-move 1: (((1 tagged-value-address)) <- ((new)) ((tagged-value literal)))
run: maybe-coerce/read-file/read-move 1: 101155 => ((1 tagged-value-address))
mem: ((1 tagged-value-address)): 101126 <= 101155
run: maybe-coerce/read-file/read-move 2: (((1 tagged-value-address) (deref)) <- ((next-input)))
arg: nil 0 (#(tagged record (character #\a . nil)) character)
run: maybe-coerce/read-file/read-move 2: #(tagged record (character #\a . nil)) => ((1 tagged-value-address) (deref))
mem: ((1 tagged-value-address) (deref)): 101155 <= character
mem: ((1 tagged-value-address) (deref)): 101156 <= #\a
run: maybe-coerce/read-file/read-move 3: (((2 type)) <- ((next-input)))
arg: nil 1 (#(tagged record (character #\a . nil)) character)
run: maybe-coerce/read-file/read-move 3: character => ((2 type))
mem: ((2 type)): 101127 <= character
run: maybe-coerce/read-file/read-move 4: (((3 type)) <- ((get)) ((1 tagged-value-address) (deref)) ((0 offset)))
mem: ((101155 type) (raw)) => character
run: maybe-coerce/read-file/read-move 4: character => ((3 type))
mem: ((3 type)): 101128 <= character
run: maybe-coerce/read-file/read-move 5: (((4 boolean)) <- ((equal)) ((3 type)) ((2 type)))
mem: ((3 type)) => character
mem: ((2 type)) => character
run: maybe-coerce/read-file/read-move 5: t => ((4 boolean))
mem: ((4 boolean)): 101129 <= t
run: maybe-coerce/read-file/read-move 6: (((jump-if)) ((4 boolean)) ((1 offset)))
mem: ((4 boolean)) => t
run: maybe-coerce/read-file/read-move 8: (((5 location)) <- ((get)) ((1 tagged-value-address) (deref)) ((1 offset)))
mem: ((101156 location) (raw)) => a
run: maybe-coerce/read-file/read-move 8: #\a => ((5 location))
mem: ((5 location)): 101130 <= #\a
run: maybe-coerce/read-file/read-move 9: (((reply)) ((5 location)) ((4 boolean)))
mem: ((5 location)) => a
mem: ((4 boolean)) => t
run: read-file/read-move 5: #\a => ((6 character))
mem: ((6 character)): 101038 <= #\a
run: read-file/read-move 6: (((7 boolean)) <- ((equal)) ((6 character)) ((q literal)))
mem: ((6 character)) => a
run: read-file/read-move 6: nil => ((7 boolean))
mem: ((7 boolean)): 101039 <= nil
run: read-file/read-move 7: (((jump-unless)) ((7 boolean)) ((1 offset)))
mem: ((7 boolean)) => nil
run: read-file/read-move 9: (((8 integer)) <- ((character-to-integer)) ((6 character)))
mem: ((6 character)) => a
run: read-file/read-move 9: 97 => ((8 integer))
mem: ((8 integer)): 101040 <= 97
run: read-file/read-move 10: (((8 integer)) <- ((subtract)) ((8 integer)) ((5 integer)))
mem: ((8 integer)) => 97
mem: ((5 integer)) => 97
run: read-file/read-move 10: 0 => ((8 integer))
mem: ((8 integer)): 101040 <= 0
run: read-file/read-move 11: (((9 boolean)) <- ((greater-or-equal)) ((8 integer)) ((0 literal)))
mem: ((8 integer)) => 0
run: read-file/read-move 11: t => ((9 boolean))
mem: ((9 boolean)): 101041 <= t
run: read-file/read-move 12: (((assert)) ((9 boolean)) ((file too low literal)))
mem: ((9 boolean)) => t
run: read-file/read-move 13: (((10 boolean)) <- ((lesser-or-equal)) ((8 integer)) ((7 literal)))
mem: ((8 integer)) => 0
run: read-file/read-move 13: t => ((10 boolean))
mem: ((10 boolean)): 101042 <= t
run: read-file/read-move 14: (((assert)) ((10 boolean)) ((file too high literal)))
mem: ((10 boolean)) => t
run: read-file/read-move 15: (((reply)) ((8 integer)))
mem: ((8 integer)) => 0
run: read-move 2: 0 => ((2 integer))
mem: ((2 integer)): 101003 <= 0
run: read-move 3: (((jump-if)) ((2 integer)) ((1 offset)))
mem: ((2 integer)) => 0
run: read-move 5: (((3 integer)) <- ((read-rank)) ((1 channel-address)))
mem: ((1 channel-address)) => 1062
run: read-rank/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: read-rank/read-move 0: 101157 => ((default-space space-address))
run: read-rank/read-move 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062)
run: read-rank/read-move 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 101159 <= 1062
run: read-rank/read-move 2: (((2 tagged-value)) ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
mem: ((1 channel-address)) => 1062
run: read/read-rank/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: read/read-rank/read-move 0: 101188 => ((default-space space-address))
run: read/read-rank/read-move 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062)
run: read/read-rank/read-move 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 101190 <= 1062
run: read/read-rank/read-move 2: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
mem: ((1 channel-address) (deref)) => #(tagged record (1 1 1065 . nil))
run: empty?/read/read-rank/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: empty?/read/read-rank/read-move 0: 101219 => ((default-space space-address))
run: empty?/read/read-rank/read-move 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (1 1 1065 . nil)))
run: empty?/read/read-rank/read-move 1: #(tagged record (1 1 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 101221 <= 1
mem: ((1 channel)): 101222 <= 1
mem: ((1 channel)): 101223 <= 1065
run: empty?/read/read-rank/read-move 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
mem: ((101221 integer) (raw)) => 1
run: empty?/read/read-rank/read-move 2: 1 => ((4 integer))
mem: ((4 integer)): 101224 <= 1
run: empty?/read/read-rank/read-move 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
mem: ((101222 integer) (raw)) => 1
run: empty?/read/read-rank/read-move 3: 1 => ((5 integer))
mem: ((5 integer)): 101225 <= 1
run: empty?/read/read-rank/read-move 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
mem: ((4 integer)) => 1
mem: ((5 integer)) => 1
run: empty?/read/read-rank/read-move 4: t => ((6 boolean))
mem: ((6 boolean)): 101226 <= t
run: empty?/read/read-rank/read-move 5: (((reply)) ((6 boolean)))
mem: ((6 boolean)) => t
run: read/read-rank/read-move 2: t => ((2 boolean))
mem: ((2 boolean)): 101191 <= t
run: read/read-rank/read-move 3: (((jump-unless)) ((2 boolean)) ((2 offset)))
mem: ((2 boolean)) => t
run: read/read-rank/read-move 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
run: read/read-rank/read-move 4: 1063 => ((3 integer-address))
mem: ((3 integer-address)): 101192 <= 1063
run: read/read-rank/read-move 5: (((sleep)) ((until-location-changes literal)) ((3 integer-address) (deref)))
mem: ((3 integer-address) (deref)) => 1
schedule: pushing read/read-rank/read-move to sleep queue
schedule: waking up write/main
schedule: write/main
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
mem: ((1064 tagged-value-array-address) (raw)) => 1065
run: write/main 7: 1065 => ((6 tagged-value-array-address))
mem: ((6 tagged-value-array-address)): 1170 <= 1065
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
run: write/main 8: 1063 => ((7 integer-address))
mem: ((7 integer-address)): 1171 <= 1063
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
mem: ((7 integer-address) (deref)) => 1
array-len: ((1065 tagged-value-array) (raw))
mem: ((1065 integer) (raw)) => 2
run: write/main 9: 1068 => ((8 tagged-value-address))
mem: ((8 tagged-value-address)): 1172 <= 1068
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
mem: ((2 tagged-value)) => #(tagged record (character 2 . nil))
run: write/main 10: #(tagged record (character #\2 . nil)) => ((8 tagged-value-address) (deref))
mem: ((8 tagged-value-address) (deref)): 1068 <= character
mem: ((8 tagged-value-address) (deref)): 1069 <= #\2
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
mem: ((7 integer-address) (deref)) => 1
run: write/main 11: 2 => ((7 integer-address) (deref))
mem: ((7 integer-address) (deref)): 1063 <= 2
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
array-len: ((6 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: write/main 12: 2 => ((9 integer))
mem: ((9 integer)): 1173 <= 2
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
mem: ((7 integer-address) (deref)) => 2
mem: ((9 integer)) => 2
run: write/main 13: nil => ((10 boolean))
mem: ((10 boolean)): 1174 <= nil
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
mem: ((10 boolean)) => nil
run: write/main 15: (((7 integer-address) (deref)) <- ((copy)) ((0 literal)))
run: write/main 15: 0 => ((7 integer-address) (deref))
mem: ((7 integer-address) (deref)): 1063 <= 0
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (1 0 1065 . nil))
run: main 8: #(tagged record (1 0 1065 . nil)) => ((1 channel-address) (deref))
mem: ((1 channel-address) (deref)): 1062 <= 1
mem: ((1 channel-address) (deref)): 1063 <= 0
mem: ((1 channel-address) (deref)): 1064 <= 1065
run: main 9: (((3 character)) <- ((copy)) ((- literal)))
run: main 9: #\- => ((3 character))
mem: ((3 character)): 1004 <= #\-
run: main 10: (((4 tagged-value)) <- ((save-type)) ((3 character)))
mem: ((3 character)) => -
run: main 10: #(tagged record (character #\-)) => ((4 tagged-value))
mem: ((4 tagged-value)): 1005 <= character
mem: ((4 tagged-value)): 1006 <= #\-
run: main 11: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((4 tagged-value)))
mem: ((1 channel-address)) => 1062
mem: ((4 tagged-value)) => #(tagged record (character - . nil))
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: write/main 0: 1256 => ((default-space space-address))
run: write/main 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062 #(tagged record (character #\- . nil)))
run: write/main 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 1258 <= 1062
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
arg: nil 1 (1062 #(tagged record (character #\- . nil)))
run: write/main 2: #(tagged record (character #\- . nil)) => ((2 tagged-value))
mem: ((2 tagged-value)): 1259 <= character
mem: ((2 tagged-value)): 1260 <= #\-
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
mem: ((1 channel-address) (deref)) => #(tagged record (1 0 1065 . nil))
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: full?/write/main 0: 1287 => ((default-space space-address))
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (1 0 1065 . nil)))
run: full?/write/main 1: #(tagged record (1 0 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 1289 <= 1
mem: ((1 channel)): 1290 <= 0
mem: ((1 channel)): 1291 <= 1065
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
mem: ((1290 integer) (raw)) => 0
run: full?/write/main 2: 0 => ((4 integer))
mem: ((4 integer)): 1292 <= 0
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
mem: ((4 integer)) => 0
run: full?/write/main 3: 1 => ((4 integer))
mem: ((4 integer)): 1292 <= 1
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
mem: ((1 channel)) => #(tagged record (1 0 1065 . nil))
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: capacity/full?/write/main 0: 1318 => ((default-space space-address))
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (1 0 1065 . nil)))
run: capacity/full?/write/main 1: #(tagged record (1 0 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 1320 <= 1
mem: ((1 channel)): 1321 <= 0
mem: ((1 channel)): 1322 <= 1065
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
mem: ((1322 tagged-value-array-address) (raw)) => 1065
run: capacity/full?/write/main 2: 1065 => ((4 tagged-value-array-address))
mem: ((4 tagged-value-array-address)): 1323 <= 1065
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
array-len: ((4 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: capacity/full?/write/main 3: 2 => ((5 integer))
mem: ((5 integer)): 1324 <= 2
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
mem: ((5 integer)) => 2
run: full?/write/main 4: 2 => ((5 integer))
mem: ((5 integer)): 1293 <= 2
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
mem: ((4 integer)) => 1
mem: ((5 integer)) => 2
run: full?/write/main 5: t => ((6 boolean))
mem: ((6 boolean)): 1294 <= t
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
mem: ((6 boolean)) => t
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
mem: ((1289 integer) (raw)) => 1
run: full?/write/main 8: 1 => ((7 integer))
mem: ((7 integer)): 1295 <= 1
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
mem: ((7 integer)) => 1
mem: ((4 integer)) => 1
run: full?/write/main 9: t => ((8 boolean))
mem: ((8 boolean)): 1296 <= t
run: full?/write/main 10: (((reply)) ((8 boolean)))
mem: ((8 boolean)) => t
run: write/main 3: t => ((4 boolean))
mem: ((4 boolean)): 1261 <= t
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
mem: ((4 boolean)) => t
run: write/main 5: (((5 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
run: write/main 5: 1062 => ((5 integer-address))
mem: ((5 integer-address)): 1262 <= 1062
run: write/main 6: (((sleep)) ((until-location-changes literal)) ((5 integer-address) (deref)))
mem: ((5 integer-address) (deref)) => 1
schedule: pushing write/main to sleep queue
schedule: waking up read/read-rank/read-move
schedule: read/read-rank/read-move
run: read/read-rank/read-move 6: (((4 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
run: read/read-rank/read-move 6: 1062 => ((4 integer-address))
mem: ((4 integer-address)): 101193 <= 1062
run: read/read-rank/read-move 7: (((5 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
mem: ((1064 tagged-value-array-address) (raw)) => 1065
run: read/read-rank/read-move 7: 1065 => ((5 tagged-value-array-address))
mem: ((5 tagged-value-array-address)): 101194 <= 1065
run: read/read-rank/read-move 8: (((6 tagged-value)) <- ((index)) ((5 tagged-value-array-address) (deref)) ((4 integer-address) (deref)))
mem: ((4 integer-address) (deref)) => 1
array-len: ((1065 tagged-value-array) (raw))
mem: ((1065 integer) (raw)) => 2
mem: ((1068 tagged-value) (raw)) => #(tagged record (character 2 . nil))
run: read/read-rank/read-move 8: #(tagged record (character #\2 . nil)) => ((6 tagged-value))
mem: ((6 tagged-value)): 101195 <= character
mem: ((6 tagged-value)): 101196 <= #\2
run: read/read-rank/read-move 9: (((4 integer-address) (deref)) <- ((add)) ((4 integer-address) (deref)) ((1 literal)))
mem: ((4 integer-address) (deref)) => 1
run: read/read-rank/read-move 9: 2 => ((4 integer-address) (deref))
mem: ((4 integer-address) (deref)): 1062 <= 2
run: read/read-rank/read-move 10: (((8 integer)) <- ((length)) ((5 tagged-value-array-address) (deref)))
array-len: ((5 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: read/read-rank/read-move 10: 2 => ((8 integer))
mem: ((8 integer)): 101197 <= 2
run: read/read-rank/read-move 11: (((9 boolean)) <- ((less-than)) ((4 integer-address) (deref)) ((8 integer)))
mem: ((4 integer-address) (deref)) => 2
mem: ((8 integer)) => 2
run: read/read-rank/read-move 11: nil => ((9 boolean))
mem: ((9 boolean)): 101198 <= nil
run: read/read-rank/read-move 12: (((jump-if)) ((9 boolean)) ((1 offset)))
mem: ((9 boolean)) => nil
run: read/read-rank/read-move 13: (((4 integer-address) (deref)) <- ((copy)) ((0 literal)))
run: read/read-rank/read-move 13: 0 => ((4 integer-address) (deref))
mem: ((4 integer-address) (deref)): 1062 <= 0
run: read/read-rank/read-move 14: (((reply)) ((6 tagged-value)) ((1 channel-address) (deref) (same-as-arg 0)))
mem: ((6 tagged-value)) => #(tagged record (character 2 . nil))
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 0 1065 . nil))
run: read-rank/read-move 2: #(tagged record (character #\2 . nil)) => ((2 tagged-value))
mem: ((2 tagged-value)): 101160 <= character
mem: ((2 tagged-value)): 101161 <= #\2
run: read-rank/read-move 2: #(tagged record (0 0 1065 . nil)) => ((1 channel-address) (deref))
mem: ((1 channel-address) (deref)): 1062 <= 0
mem: ((1 channel-address) (deref)): 1063 <= 0
mem: ((1 channel-address) (deref)): 1064 <= 1065
run: read-rank/read-move 3: (((4 character)) <- ((maybe-coerce)) ((2 tagged-value)) ((character literal)))
mem: ((2 tagged-value)) => #(tagged record (character 2 . nil))
run: maybe-coerce/read-rank/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: maybe-coerce/read-rank/read-move 0: 101250 => ((default-space space-address))
run: maybe-coerce/read-rank/read-move 1: (((1 tagged-value-address)) <- ((new)) ((tagged-value literal)))
run: maybe-coerce/read-rank/read-move 1: 101281 => ((1 tagged-value-address))
mem: ((1 tagged-value-address)): 101252 <= 101281
run: maybe-coerce/read-rank/read-move 2: (((1 tagged-value-address) (deref)) <- ((next-input)))
arg: nil 0 (#(tagged record (character #\2 . nil)) character)
run: maybe-coerce/read-rank/read-move 2: #(tagged record (character #\2 . nil)) => ((1 tagged-value-address) (deref))
mem: ((1 tagged-value-address) (deref)): 101281 <= character
mem: ((1 tagged-value-address) (deref)): 101282 <= #\2
run: maybe-coerce/read-rank/read-move 3: (((2 type)) <- ((next-input)))
arg: nil 1 (#(tagged record (character #\2 . nil)) character)
run: maybe-coerce/read-rank/read-move 3: character => ((2 type))
mem: ((2 type)): 101253 <= character
run: maybe-coerce/read-rank/read-move 4: (((3 type)) <- ((get)) ((1 tagged-value-address) (deref)) ((0 offset)))
mem: ((101281 type) (raw)) => character
run: maybe-coerce/read-rank/read-move 4: character => ((3 type))
mem: ((3 type)): 101254 <= character
run: maybe-coerce/read-rank/read-move 5: (((4 boolean)) <- ((equal)) ((3 type)) ((2 type)))
mem: ((3 type)) => character
mem: ((2 type)) => character
run: maybe-coerce/read-rank/read-move 5: t => ((4 boolean))
mem: ((4 boolean)): 101255 <= t
run: maybe-coerce/read-rank/read-move 6: (((jump-if)) ((4 boolean)) ((1 offset)))
mem: ((4 boolean)) => t
run: maybe-coerce/read-rank/read-move 8: (((5 location)) <- ((get)) ((1 tagged-value-address) (deref)) ((1 offset)))
mem: ((101282 location) (raw)) => 2
run: maybe-coerce/read-rank/read-move 8: #\2 => ((5 location))
mem: ((5 location)): 101256 <= #\2
run: maybe-coerce/read-rank/read-move 9: (((reply)) ((5 location)) ((4 boolean)))
mem: ((5 location)) => 2
mem: ((4 boolean)) => t
run: read-rank/read-move 3: #\2 => ((4 character))
mem: ((4 character)): 101162 <= #\2
run: read-rank/read-move 4: (((5 boolean)) <- ((equal)) ((4 character)) ((q literal)))
mem: ((4 character)) => 2
run: read-rank/read-move 4: nil => ((5 boolean))
mem: ((5 boolean)): 101163 <= nil
run: read-rank/read-move 5: (((jump-unless)) ((5 boolean)) ((1 offset)))
mem: ((5 boolean)) => nil
run: read-rank/read-move 7: (((6 integer)) <- ((character-to-integer)) ((4 character)))
mem: ((4 character)) => 2
run: read-rank/read-move 7: 50 => ((6 integer))
mem: ((6 integer)): 101164 <= 50
run: read-rank/read-move 8: (((7 character)) <- ((copy)) ((1 literal)))
run: read-rank/read-move 8: #\1 => ((7 character))
mem: ((7 character)): 101165 <= #\1
run: read-rank/read-move 9: (((8 integer)) <- ((character-to-integer)) ((7 character)))
mem: ((7 character)) => 1
run: read-rank/read-move 9: 49 => ((8 integer))
mem: ((8 integer)): 101166 <= 49
run: read-rank/read-move 10: (((6 integer)) <- ((subtract)) ((6 integer)) ((8 integer)))
mem: ((6 integer)) => 50
mem: ((8 integer)) => 49
run: read-rank/read-move 10: 1 => ((6 integer))
mem: ((6 integer)): 101164 <= 1
run: read-rank/read-move 11: (((9 boolean)) <- ((greater-or-equal)) ((6 integer)) ((0 literal)))
mem: ((6 integer)) => 1
run: read-rank/read-move 11: t => ((9 boolean))
mem: ((9 boolean)): 101167 <= t
run: read-rank/read-move 12: (((assert)) ((9 boolean)) ((rank too low literal)))
mem: ((9 boolean)) => t
run: read-rank/read-move 13: (((10 boolean)) <- ((lesser-or-equal)) ((6 integer)) ((7 literal)))
mem: ((6 integer)) => 1
run: read-rank/read-move 13: t => ((10 boolean))
mem: ((10 boolean)): 101168 <= t
run: read-rank/read-move 14: (((assert)) ((10 boolean)) ((rank too high literal)))
mem: ((10 boolean)) => t
run: read-rank/read-move 15: (((reply)) ((6 integer)))
mem: ((6 integer)) => 1
run: read-move 5: 1 => ((3 integer))
mem: ((3 integer)): 101004 <= 1
run: read-move 6: (((expect-stdin)) ((1 channel-address)) ((- literal)))
mem: ((1 channel-address)) => 1062
run: expect-stdin/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: expect-stdin/read-move 0: 101283 => ((default-space space-address))
run: expect-stdin/read-move 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062 #\-)
run: expect-stdin/read-move 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 101285 <= 1062
run: expect-stdin/read-move 2: (((2 tagged-value)) ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
mem: ((1 channel-address)) => 1062
run: read/expect-stdin/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: read/expect-stdin/read-move 0: 101314 => ((default-space space-address))
run: read/expect-stdin/read-move 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062)
run: read/expect-stdin/read-move 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 101316 <= 1062
run: read/expect-stdin/read-move 2: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1065 . nil))
run: empty?/read/expect-stdin/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: empty?/read/expect-stdin/read-move 0: 101345 => ((default-space space-address))
run: empty?/read/expect-stdin/read-move 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (0 0 1065 . nil)))
run: empty?/read/expect-stdin/read-move 1: #(tagged record (0 0 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 101347 <= 0
mem: ((1 channel)): 101348 <= 0
mem: ((1 channel)): 101349 <= 1065
run: empty?/read/expect-stdin/read-move 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
mem: ((101347 integer) (raw)) => 0
run: empty?/read/expect-stdin/read-move 2: 0 => ((4 integer))
mem: ((4 integer)): 101350 <= 0
run: empty?/read/expect-stdin/read-move 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
mem: ((101348 integer) (raw)) => 0
run: empty?/read/expect-stdin/read-move 3: 0 => ((5 integer))
mem: ((5 integer)): 101351 <= 0
run: empty?/read/expect-stdin/read-move 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
mem: ((4 integer)) => 0
mem: ((5 integer)) => 0
run: empty?/read/expect-stdin/read-move 4: t => ((6 boolean))
mem: ((6 boolean)): 101352 <= t
run: empty?/read/expect-stdin/read-move 5: (((reply)) ((6 boolean)))
mem: ((6 boolean)) => t
run: read/expect-stdin/read-move 2: t => ((2 boolean))
mem: ((2 boolean)): 101317 <= t
run: read/expect-stdin/read-move 3: (((jump-unless)) ((2 boolean)) ((2 offset)))
mem: ((2 boolean)) => t
run: read/expect-stdin/read-move 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
run: read/expect-stdin/read-move 4: 1063 => ((3 integer-address))
mem: ((3 integer-address)): 101318 <= 1063
run: read/expect-stdin/read-move 5: (((sleep)) ((until-location-changes literal)) ((3 integer-address) (deref)))
mem: ((3 integer-address) (deref)) => 0
schedule: pushing read/expect-stdin/read-move to sleep queue
schedule: waking up write/main
schedule: write/main
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
mem: ((1064 tagged-value-array-address) (raw)) => 1065
run: write/main 7: 1065 => ((6 tagged-value-array-address))
mem: ((6 tagged-value-array-address)): 1263 <= 1065
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
run: write/main 8: 1063 => ((7 integer-address))
mem: ((7 integer-address)): 1264 <= 1063
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
mem: ((7 integer-address) (deref)) => 0
array-len: ((1065 tagged-value-array) (raw))
mem: ((1065 integer) (raw)) => 2
run: write/main 9: 1066 => ((8 tagged-value-address))
mem: ((8 tagged-value-address)): 1265 <= 1066
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
mem: ((2 tagged-value)) => #(tagged record (character - . nil))
run: write/main 10: #(tagged record (character #\- . nil)) => ((8 tagged-value-address) (deref))
mem: ((8 tagged-value-address) (deref)): 1066 <= character
mem: ((8 tagged-value-address) (deref)): 1067 <= #\-
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
mem: ((7 integer-address) (deref)) => 0
run: write/main 11: 1 => ((7 integer-address) (deref))
mem: ((7 integer-address) (deref)): 1063 <= 1
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
array-len: ((6 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: write/main 12: 2 => ((9 integer))
mem: ((9 integer)): 1266 <= 2
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
mem: ((7 integer-address) (deref)) => 1
mem: ((9 integer)) => 2
run: write/main 13: t => ((10 boolean))
mem: ((10 boolean)): 1267 <= t
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
mem: ((10 boolean)) => t
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 1 1065 . nil))
run: main 11: #(tagged record (0 1 1065 . nil)) => ((1 channel-address) (deref))
mem: ((1 channel-address) (deref)): 1062 <= 0
mem: ((1 channel-address) (deref)): 1063 <= 1
mem: ((1 channel-address) (deref)): 1064 <= 1065
run: main 12: (((3 character)) <- ((copy)) ((a literal)))
run: main 12: #\a => ((3 character))
mem: ((3 character)): 1004 <= #\a
run: main 13: (((4 tagged-value)) <- ((save-type)) ((3 character)))
mem: ((3 character)) => a
run: main 13: #(tagged record (character #\a)) => ((4 tagged-value))
mem: ((4 tagged-value)): 1005 <= character
mem: ((4 tagged-value)): 1006 <= #\a
run: main 14: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((4 tagged-value)))
mem: ((1 channel-address)) => 1062
mem: ((4 tagged-value)) => #(tagged record (character a . nil))
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: write/main 0: 1349 => ((default-space space-address))
run: write/main 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062 #(tagged record (character #\a . nil)))
run: write/main 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 1351 <= 1062
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
arg: nil 1 (1062 #(tagged record (character #\a . nil)))
run: write/main 2: #(tagged record (character #\a . nil)) => ((2 tagged-value))
mem: ((2 tagged-value)): 1352 <= character
mem: ((2 tagged-value)): 1353 <= #\a
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
mem: ((1 channel-address) (deref)) => #(tagged record (0 1 1065 . nil))
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: full?/write/main 0: 1380 => ((default-space space-address))
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (0 1 1065 . nil)))
run: full?/write/main 1: #(tagged record (0 1 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 1382 <= 0
mem: ((1 channel)): 1383 <= 1
mem: ((1 channel)): 1384 <= 1065
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
mem: ((1383 integer) (raw)) => 1
run: full?/write/main 2: 1 => ((4 integer))
mem: ((4 integer)): 1385 <= 1
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
mem: ((4 integer)) => 1
run: full?/write/main 3: 2 => ((4 integer))
mem: ((4 integer)): 1385 <= 2
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
mem: ((1 channel)) => #(tagged record (0 1 1065 . nil))
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: capacity/full?/write/main 0: 1411 => ((default-space space-address))
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (0 1 1065 . nil)))
run: capacity/full?/write/main 1: #(tagged record (0 1 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 1413 <= 0
mem: ((1 channel)): 1414 <= 1
mem: ((1 channel)): 1415 <= 1065
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
mem: ((1415 tagged-value-array-address) (raw)) => 1065
run: capacity/full?/write/main 2: 1065 => ((4 tagged-value-array-address))
mem: ((4 tagged-value-array-address)): 1416 <= 1065
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
array-len: ((4 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: capacity/full?/write/main 3: 2 => ((5 integer))
mem: ((5 integer)): 1417 <= 2
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
mem: ((5 integer)) => 2
run: full?/write/main 4: 2 => ((5 integer))
mem: ((5 integer)): 1386 <= 2
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
mem: ((4 integer)) => 2
mem: ((5 integer)) => 2
run: full?/write/main 5: nil => ((6 boolean))
mem: ((6 boolean)): 1387 <= nil
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
mem: ((6 boolean)) => nil
run: full?/write/main 7: (((4 integer)) <- ((copy)) ((0 literal)))
run: full?/write/main 7: 0 => ((4 integer))
mem: ((4 integer)): 1385 <= 0
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
mem: ((1382 integer) (raw)) => 0
run: full?/write/main 8: 0 => ((7 integer))
mem: ((7 integer)): 1388 <= 0
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
mem: ((7 integer)) => 0
mem: ((4 integer)) => 0
run: full?/write/main 9: t => ((8 boolean))
mem: ((8 boolean)): 1389 <= t
run: full?/write/main 10: (((reply)) ((8 boolean)))
mem: ((8 boolean)) => t
run: write/main 3: t => ((4 boolean))
mem: ((4 boolean)): 1354 <= t
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
mem: ((4 boolean)) => t
run: write/main 5: (((5 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
run: write/main 5: 1062 => ((5 integer-address))
mem: ((5 integer-address)): 1355 <= 1062
run: write/main 6: (((sleep)) ((until-location-changes literal)) ((5 integer-address) (deref)))
mem: ((5 integer-address) (deref)) => 0
schedule: pushing write/main to sleep queue
schedule: waking up read/expect-stdin/read-move
schedule: read/expect-stdin/read-move
run: read/expect-stdin/read-move 6: (((4 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
run: read/expect-stdin/read-move 6: 1062 => ((4 integer-address))
mem: ((4 integer-address)): 101319 <= 1062
run: read/expect-stdin/read-move 7: (((5 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
mem: ((1064 tagged-value-array-address) (raw)) => 1065
run: read/expect-stdin/read-move 7: 1065 => ((5 tagged-value-array-address))
mem: ((5 tagged-value-array-address)): 101320 <= 1065
run: read/expect-stdin/read-move 8: (((6 tagged-value)) <- ((index)) ((5 tagged-value-array-address) (deref)) ((4 integer-address) (deref)))
mem: ((4 integer-address) (deref)) => 0
array-len: ((1065 tagged-value-array) (raw))
mem: ((1065 integer) (raw)) => 2
mem: ((1066 tagged-value) (raw)) => #(tagged record (character - . nil))
run: read/expect-stdin/read-move 8: #(tagged record (character #\- . nil)) => ((6 tagged-value))
mem: ((6 tagged-value)): 101321 <= character
mem: ((6 tagged-value)): 101322 <= #\-
run: read/expect-stdin/read-move 9: (((4 integer-address) (deref)) <- ((add)) ((4 integer-address) (deref)) ((1 literal)))
mem: ((4 integer-address) (deref)) => 0
run: read/expect-stdin/read-move 9: 1 => ((4 integer-address) (deref))
mem: ((4 integer-address) (deref)): 1062 <= 1
run: read/expect-stdin/read-move 10: (((8 integer)) <- ((length)) ((5 tagged-value-array-address) (deref)))
array-len: ((5 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: read/expect-stdin/read-move 10: 2 => ((8 integer))
mem: ((8 integer)): 101323 <= 2
run: read/expect-stdin/read-move 11: (((9 boolean)) <- ((less-than)) ((4 integer-address) (deref)) ((8 integer)))
mem: ((4 integer-address) (deref)) => 1
mem: ((8 integer)) => 2
run: read/expect-stdin/read-move 11: t => ((9 boolean))
mem: ((9 boolean)): 101324 <= t
run: read/expect-stdin/read-move 12: (((jump-if)) ((9 boolean)) ((1 offset)))
mem: ((9 boolean)) => t
run: read/expect-stdin/read-move 14: (((reply)) ((6 tagged-value)) ((1 channel-address) (deref) (same-as-arg 0)))
mem: ((6 tagged-value)) => #(tagged record (character - . nil))
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (1 1 1065 . nil))
run: expect-stdin/read-move 2: #(tagged record (character #\- . nil)) => ((2 tagged-value))
mem: ((2 tagged-value)): 101286 <= character
mem: ((2 tagged-value)): 101287 <= #\-
run: expect-stdin/read-move 2: #(tagged record (1 1 1065 . nil)) => ((1 channel-address) (deref))
mem: ((1 channel-address) (deref)): 1062 <= 1
mem: ((1 channel-address) (deref)): 1063 <= 1
mem: ((1 channel-address) (deref)): 1064 <= 1065
run: expect-stdin/read-move 3: (((4 character)) <- ((maybe-coerce)) ((2 tagged-value)) ((character literal)))
mem: ((2 tagged-value)) => #(tagged record (character - . nil))
run: maybe-coerce/expect-stdin/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: maybe-coerce/expect-stdin/read-move 0: 101376 => ((default-space space-address))
run: maybe-coerce/expect-stdin/read-move 1: (((1 tagged-value-address)) <- ((new)) ((tagged-value literal)))
run: maybe-coerce/expect-stdin/read-move 1: 101407 => ((1 tagged-value-address))
mem: ((1 tagged-value-address)): 101378 <= 101407
run: maybe-coerce/expect-stdin/read-move 2: (((1 tagged-value-address) (deref)) <- ((next-input)))
arg: nil 0 (#(tagged record (character #\- . nil)) character)
run: maybe-coerce/expect-stdin/read-move 2: #(tagged record (character #\- . nil)) => ((1 tagged-value-address) (deref))
mem: ((1 tagged-value-address) (deref)): 101407 <= character
mem: ((1 tagged-value-address) (deref)): 101408 <= #\-
run: maybe-coerce/expect-stdin/read-move 3: (((2 type)) <- ((next-input)))
arg: nil 1 (#(tagged record (character #\- . nil)) character)
run: maybe-coerce/expect-stdin/read-move 3: character => ((2 type))
mem: ((2 type)): 101379 <= character
run: maybe-coerce/expect-stdin/read-move 4: (((3 type)) <- ((get)) ((1 tagged-value-address) (deref)) ((0 offset)))
mem: ((101407 type) (raw)) => character
run: maybe-coerce/expect-stdin/read-move 4: character => ((3 type))
mem: ((3 type)): 101380 <= character
run: maybe-coerce/expect-stdin/read-move 5: (((4 boolean)) <- ((equal)) ((3 type)) ((2 type)))
mem: ((3 type)) => character
mem: ((2 type)) => character
run: maybe-coerce/expect-stdin/read-move 5: t => ((4 boolean))
mem: ((4 boolean)): 101381 <= t
run: maybe-coerce/expect-stdin/read-move 6: (((jump-if)) ((4 boolean)) ((1 offset)))
mem: ((4 boolean)) => t
run: maybe-coerce/expect-stdin/read-move 8: (((5 location)) <- ((get)) ((1 tagged-value-address) (deref)) ((1 offset)))
mem: ((101408 location) (raw)) => -
run: maybe-coerce/expect-stdin/read-move 8: #\- => ((5 location))
mem: ((5 location)): 101382 <= #\-
run: maybe-coerce/expect-stdin/read-move 9: (((reply)) ((5 location)) ((4 boolean)))
mem: ((5 location)) => -
mem: ((4 boolean)) => t
run: expect-stdin/read-move 3: #\- => ((4 character))
mem: ((4 character)): 101288 <= #\-
run: expect-stdin/read-move 4: (((5 character)) <- ((next-input)))
arg: nil 1 (1062 #\-)
run: expect-stdin/read-move 4: #\- => ((5 character))
mem: ((5 character)): 101289 <= #\-
run: expect-stdin/read-move 5: (((6 boolean)) <- ((equal)) ((4 character)) ((5 character)))
mem: ((4 character)) => -
mem: ((5 character)) => -
run: expect-stdin/read-move 5: t => ((6 boolean))
mem: ((6 boolean)): 101290 <= t
run: expect-stdin/read-move 6: (((assert)) ((6 boolean)) ((expected character not found literal)))
mem: ((6 boolean)) => t
run: read-move 7: (((4 integer)) <- ((read-file)) ((1 channel-address)))
mem: ((1 channel-address)) => 1062
run: read-file/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: read-file/read-move 0: 101409 => ((default-space space-address))
run: read-file/read-move 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062)
run: read-file/read-move 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 101411 <= 1062
run: read-file/read-move 2: (((2 tagged-value)) ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
mem: ((1 channel-address)) => 1062
run: read/read-file/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: read/read-file/read-move 0: 101440 => ((default-space space-address))
run: read/read-file/read-move 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062)
run: read/read-file/read-move 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 101442 <= 1062
run: read/read-file/read-move 2: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
mem: ((1 channel-address) (deref)) => #(tagged record (1 1 1065 . nil))
run: empty?/read/read-file/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: empty?/read/read-file/read-move 0: 101471 => ((default-space space-address))
run: empty?/read/read-file/read-move 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (1 1 1065 . nil)))
run: empty?/read/read-file/read-move 1: #(tagged record (1 1 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 101473 <= 1
mem: ((1 channel)): 101474 <= 1
mem: ((1 channel)): 101475 <= 1065
run: empty?/read/read-file/read-move 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
mem: ((101473 integer) (raw)) => 1
run: empty?/read/read-file/read-move 2: 1 => ((4 integer))
mem: ((4 integer)): 101476 <= 1
run: empty?/read/read-file/read-move 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
mem: ((101474 integer) (raw)) => 1
run: empty?/read/read-file/read-move 3: 1 => ((5 integer))
mem: ((5 integer)): 101477 <= 1
run: empty?/read/read-file/read-move 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
mem: ((4 integer)) => 1
mem: ((5 integer)) => 1
run: empty?/read/read-file/read-move 4: t => ((6 boolean))
mem: ((6 boolean)): 101478 <= t
run: empty?/read/read-file/read-move 5: (((reply)) ((6 boolean)))
mem: ((6 boolean)) => t
run: read/read-file/read-move 2: t => ((2 boolean))
mem: ((2 boolean)): 101443 <= t
run: read/read-file/read-move 3: (((jump-unless)) ((2 boolean)) ((2 offset)))
mem: ((2 boolean)) => t
run: read/read-file/read-move 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
run: read/read-file/read-move 4: 1063 => ((3 integer-address))
mem: ((3 integer-address)): 101444 <= 1063
run: read/read-file/read-move 5: (((sleep)) ((until-location-changes literal)) ((3 integer-address) (deref)))
mem: ((3 integer-address) (deref)) => 1
schedule: pushing read/read-file/read-move to sleep queue
schedule: waking up write/main
schedule: write/main
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
mem: ((1064 tagged-value-array-address) (raw)) => 1065
run: write/main 7: 1065 => ((6 tagged-value-array-address))
mem: ((6 tagged-value-array-address)): 1356 <= 1065
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
run: write/main 8: 1063 => ((7 integer-address))
mem: ((7 integer-address)): 1357 <= 1063
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
mem: ((7 integer-address) (deref)) => 1
array-len: ((1065 tagged-value-array) (raw))
mem: ((1065 integer) (raw)) => 2
run: write/main 9: 1068 => ((8 tagged-value-address))
mem: ((8 tagged-value-address)): 1358 <= 1068
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
mem: ((2 tagged-value)) => #(tagged record (character a . nil))
run: write/main 10: #(tagged record (character #\a . nil)) => ((8 tagged-value-address) (deref))
mem: ((8 tagged-value-address) (deref)): 1068 <= character
mem: ((8 tagged-value-address) (deref)): 1069 <= #\a
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
mem: ((7 integer-address) (deref)) => 1
run: write/main 11: 2 => ((7 integer-address) (deref))
mem: ((7 integer-address) (deref)): 1063 <= 2
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
array-len: ((6 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: write/main 12: 2 => ((9 integer))
mem: ((9 integer)): 1359 <= 2
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
mem: ((7 integer-address) (deref)) => 2
mem: ((9 integer)) => 2
run: write/main 13: nil => ((10 boolean))
mem: ((10 boolean)): 1360 <= nil
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
mem: ((10 boolean)) => nil
run: write/main 15: (((7 integer-address) (deref)) <- ((copy)) ((0 literal)))
run: write/main 15: 0 => ((7 integer-address) (deref))
mem: ((7 integer-address) (deref)): 1063 <= 0
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (1 0 1065 . nil))
run: main 14: #(tagged record (1 0 1065 . nil)) => ((1 channel-address) (deref))
mem: ((1 channel-address) (deref)): 1062 <= 1
mem: ((1 channel-address) (deref)): 1063 <= 0
mem: ((1 channel-address) (deref)): 1064 <= 1065
run: main 15: (((3 character)) <- ((copy)) ((4 literal)))
run: main 15: #\4 => ((3 character))
mem: ((3 character)): 1004 <= #\4
run: main 16: (((4 tagged-value)) <- ((save-type)) ((3 character)))
mem: ((3 character)) => 4
run: main 16: #(tagged record (character #\4)) => ((4 tagged-value))
mem: ((4 tagged-value)): 1005 <= character
mem: ((4 tagged-value)): 1006 <= #\4
run: main 17: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((4 tagged-value)))
mem: ((1 channel-address)) => 1062
mem: ((4 tagged-value)) => #(tagged record (character 4 . nil))
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: write/main 0: 1442 => ((default-space space-address))
run: write/main 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062 #(tagged record (character #\4 . nil)))
run: write/main 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 1444 <= 1062
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
arg: nil 1 (1062 #(tagged record (character #\4 . nil)))
run: write/main 2: #(tagged record (character #\4 . nil)) => ((2 tagged-value))
mem: ((2 tagged-value)): 1445 <= character
mem: ((2 tagged-value)): 1446 <= #\4
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
mem: ((1 channel-address) (deref)) => #(tagged record (1 0 1065 . nil))
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: full?/write/main 0: 1473 => ((default-space space-address))
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (1 0 1065 . nil)))
run: full?/write/main 1: #(tagged record (1 0 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 1475 <= 1
mem: ((1 channel)): 1476 <= 0
mem: ((1 channel)): 1477 <= 1065
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
mem: ((1476 integer) (raw)) => 0
run: full?/write/main 2: 0 => ((4 integer))
mem: ((4 integer)): 1478 <= 0
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
mem: ((4 integer)) => 0
run: full?/write/main 3: 1 => ((4 integer))
mem: ((4 integer)): 1478 <= 1
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
mem: ((1 channel)) => #(tagged record (1 0 1065 . nil))
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: capacity/full?/write/main 0: 1504 => ((default-space space-address))
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (1 0 1065 . nil)))
run: capacity/full?/write/main 1: #(tagged record (1 0 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 1506 <= 1
mem: ((1 channel)): 1507 <= 0
mem: ((1 channel)): 1508 <= 1065
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
mem: ((1508 tagged-value-array-address) (raw)) => 1065
run: capacity/full?/write/main 2: 1065 => ((4 tagged-value-array-address))
mem: ((4 tagged-value-array-address)): 1509 <= 1065
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
array-len: ((4 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: capacity/full?/write/main 3: 2 => ((5 integer))
mem: ((5 integer)): 1510 <= 2
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
mem: ((5 integer)) => 2
run: full?/write/main 4: 2 => ((5 integer))
mem: ((5 integer)): 1479 <= 2
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
mem: ((4 integer)) => 1
mem: ((5 integer)) => 2
run: full?/write/main 5: t => ((6 boolean))
mem: ((6 boolean)): 1480 <= t
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
mem: ((6 boolean)) => t
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
mem: ((1475 integer) (raw)) => 1
run: full?/write/main 8: 1 => ((7 integer))
mem: ((7 integer)): 1481 <= 1
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
mem: ((7 integer)) => 1
mem: ((4 integer)) => 1
run: full?/write/main 9: t => ((8 boolean))
mem: ((8 boolean)): 1482 <= t
run: full?/write/main 10: (((reply)) ((8 boolean)))
mem: ((8 boolean)) => t
run: write/main 3: t => ((4 boolean))
mem: ((4 boolean)): 1447 <= t
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
mem: ((4 boolean)) => t
run: write/main 5: (((5 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
run: write/main 5: 1062 => ((5 integer-address))
mem: ((5 integer-address)): 1448 <= 1062
run: write/main 6: (((sleep)) ((until-location-changes literal)) ((5 integer-address) (deref)))
mem: ((5 integer-address) (deref)) => 1
schedule: pushing write/main to sleep queue
schedule: waking up read/read-file/read-move
schedule: read/read-file/read-move
run: read/read-file/read-move 6: (((4 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
run: read/read-file/read-move 6: 1062 => ((4 integer-address))
mem: ((4 integer-address)): 101445 <= 1062
run: read/read-file/read-move 7: (((5 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
mem: ((1064 tagged-value-array-address) (raw)) => 1065
run: read/read-file/read-move 7: 1065 => ((5 tagged-value-array-address))
mem: ((5 tagged-value-array-address)): 101446 <= 1065
run: read/read-file/read-move 8: (((6 tagged-value)) <- ((index)) ((5 tagged-value-array-address) (deref)) ((4 integer-address) (deref)))
mem: ((4 integer-address) (deref)) => 1
array-len: ((1065 tagged-value-array) (raw))
mem: ((1065 integer) (raw)) => 2
mem: ((1068 tagged-value) (raw)) => #(tagged record (character a . nil))
run: read/read-file/read-move 8: #(tagged record (character #\a . nil)) => ((6 tagged-value))
mem: ((6 tagged-value)): 101447 <= character
mem: ((6 tagged-value)): 101448 <= #\a
run: read/read-file/read-move 9: (((4 integer-address) (deref)) <- ((add)) ((4 integer-address) (deref)) ((1 literal)))
mem: ((4 integer-address) (deref)) => 1
run: read/read-file/read-move 9: 2 => ((4 integer-address) (deref))
mem: ((4 integer-address) (deref)): 1062 <= 2
run: read/read-file/read-move 10: (((8 integer)) <- ((length)) ((5 tagged-value-array-address) (deref)))
array-len: ((5 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: read/read-file/read-move 10: 2 => ((8 integer))
mem: ((8 integer)): 101449 <= 2
run: read/read-file/read-move 11: (((9 boolean)) <- ((less-than)) ((4 integer-address) (deref)) ((8 integer)))
mem: ((4 integer-address) (deref)) => 2
mem: ((8 integer)) => 2
run: read/read-file/read-move 11: nil => ((9 boolean))
mem: ((9 boolean)): 101450 <= nil
run: read/read-file/read-move 12: (((jump-if)) ((9 boolean)) ((1 offset)))
mem: ((9 boolean)) => nil
run: read/read-file/read-move 13: (((4 integer-address) (deref)) <- ((copy)) ((0 literal)))
run: read/read-file/read-move 13: 0 => ((4 integer-address) (deref))
mem: ((4 integer-address) (deref)): 1062 <= 0
run: read/read-file/read-move 14: (((reply)) ((6 tagged-value)) ((1 channel-address) (deref) (same-as-arg 0)))
mem: ((6 tagged-value)) => #(tagged record (character a . nil))
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 0 1065 . nil))
run: read-file/read-move 2: #(tagged record (character #\a . nil)) => ((2 tagged-value))
mem: ((2 tagged-value)): 101412 <= character
mem: ((2 tagged-value)): 101413 <= #\a
run: read-file/read-move 2: #(tagged record (0 0 1065 . nil)) => ((1 channel-address) (deref))
mem: ((1 channel-address) (deref)): 1062 <= 0
mem: ((1 channel-address) (deref)): 1063 <= 0
mem: ((1 channel-address) (deref)): 1064 <= 1065
run: read-file/read-move 3: (((4 character)) <- ((copy)) ((a literal)))
run: read-file/read-move 3: #\a => ((4 character))
mem: ((4 character)): 101414 <= #\a
run: read-file/read-move 4: (((5 integer)) <- ((character-to-integer)) ((4 character)))
mem: ((4 character)) => a
run: read-file/read-move 4: 97 => ((5 integer))
mem: ((5 integer)): 101415 <= 97
run: read-file/read-move 5: (((6 character)) <- ((maybe-coerce)) ((2 tagged-value)) ((character literal)))
mem: ((2 tagged-value)) => #(tagged record (character a . nil))
run: maybe-coerce/read-file/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: maybe-coerce/read-file/read-move 0: 101502 => ((default-space space-address))
run: maybe-coerce/read-file/read-move 1: (((1 tagged-value-address)) <- ((new)) ((tagged-value literal)))
run: maybe-coerce/read-file/read-move 1: 101533 => ((1 tagged-value-address))
mem: ((1 tagged-value-address)): 101504 <= 101533
run: maybe-coerce/read-file/read-move 2: (((1 tagged-value-address) (deref)) <- ((next-input)))
arg: nil 0 (#(tagged record (character #\a . nil)) character)
run: maybe-coerce/read-file/read-move 2: #(tagged record (character #\a . nil)) => ((1 tagged-value-address) (deref))
mem: ((1 tagged-value-address) (deref)): 101533 <= character
mem: ((1 tagged-value-address) (deref)): 101534 <= #\a
run: maybe-coerce/read-file/read-move 3: (((2 type)) <- ((next-input)))
arg: nil 1 (#(tagged record (character #\a . nil)) character)
run: maybe-coerce/read-file/read-move 3: character => ((2 type))
mem: ((2 type)): 101505 <= character
run: maybe-coerce/read-file/read-move 4: (((3 type)) <- ((get)) ((1 tagged-value-address) (deref)) ((0 offset)))
mem: ((101533 type) (raw)) => character
run: maybe-coerce/read-file/read-move 4: character => ((3 type))
mem: ((3 type)): 101506 <= character
run: maybe-coerce/read-file/read-move 5: (((4 boolean)) <- ((equal)) ((3 type)) ((2 type)))
mem: ((3 type)) => character
mem: ((2 type)) => character
run: maybe-coerce/read-file/read-move 5: t => ((4 boolean))
mem: ((4 boolean)): 101507 <= t
run: maybe-coerce/read-file/read-move 6: (((jump-if)) ((4 boolean)) ((1 offset)))
mem: ((4 boolean)) => t
run: maybe-coerce/read-file/read-move 8: (((5 location)) <- ((get)) ((1 tagged-value-address) (deref)) ((1 offset)))
mem: ((101534 location) (raw)) => a
run: maybe-coerce/read-file/read-move 8: #\a => ((5 location))
mem: ((5 location)): 101508 <= #\a
run: maybe-coerce/read-file/read-move 9: (((reply)) ((5 location)) ((4 boolean)))
mem: ((5 location)) => a
mem: ((4 boolean)) => t
run: read-file/read-move 5: #\a => ((6 character))
mem: ((6 character)): 101416 <= #\a
run: read-file/read-move 6: (((7 boolean)) <- ((equal)) ((6 character)) ((q literal)))
mem: ((6 character)) => a
run: read-file/read-move 6: nil => ((7 boolean))
mem: ((7 boolean)): 101417 <= nil
run: read-file/read-move 7: (((jump-unless)) ((7 boolean)) ((1 offset)))
mem: ((7 boolean)) => nil
run: read-file/read-move 9: (((8 integer)) <- ((character-to-integer)) ((6 character)))
mem: ((6 character)) => a
run: read-file/read-move 9: 97 => ((8 integer))
mem: ((8 integer)): 101418 <= 97
run: read-file/read-move 10: (((8 integer)) <- ((subtract)) ((8 integer)) ((5 integer)))
mem: ((8 integer)) => 97
mem: ((5 integer)) => 97
run: read-file/read-move 10: 0 => ((8 integer))
mem: ((8 integer)): 101418 <= 0
run: read-file/read-move 11: (((9 boolean)) <- ((greater-or-equal)) ((8 integer)) ((0 literal)))
mem: ((8 integer)) => 0
run: read-file/read-move 11: t => ((9 boolean))
mem: ((9 boolean)): 101419 <= t
run: read-file/read-move 12: (((assert)) ((9 boolean)) ((file too low literal)))
mem: ((9 boolean)) => t
run: read-file/read-move 13: (((10 boolean)) <- ((lesser-or-equal)) ((8 integer)) ((7 literal)))
mem: ((8 integer)) => 0
run: read-file/read-move 13: t => ((10 boolean))
mem: ((10 boolean)): 101420 <= t
run: read-file/read-move 14: (((assert)) ((10 boolean)) ((file too high literal)))
mem: ((10 boolean)) => t
run: read-file/read-move 15: (((reply)) ((8 integer)))
mem: ((8 integer)) => 0
run: read-move 7: 0 => ((4 integer))
mem: ((4 integer)): 101005 <= 0
run: read-move 8: (((5 integer)) <- ((read-rank)) ((1 channel-address)))
mem: ((1 channel-address)) => 1062
run: read-rank/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: read-rank/read-move 0: 101535 => ((default-space space-address))
run: read-rank/read-move 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062)
run: read-rank/read-move 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 101537 <= 1062
run: read-rank/read-move 2: (((2 tagged-value)) ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
mem: ((1 channel-address)) => 1062
run: read/read-rank/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: read/read-rank/read-move 0: 101566 => ((default-space space-address))
run: read/read-rank/read-move 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062)
run: read/read-rank/read-move 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 101568 <= 1062
run: read/read-rank/read-move 2: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1065 . nil))
run: empty?/read/read-rank/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: empty?/read/read-rank/read-move 0: 101597 => ((default-space space-address))
run: empty?/read/read-rank/read-move 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (0 0 1065 . nil)))
run: empty?/read/read-rank/read-move 1: #(tagged record (0 0 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 101599 <= 0
mem: ((1 channel)): 101600 <= 0
mem: ((1 channel)): 101601 <= 1065
run: empty?/read/read-rank/read-move 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
mem: ((101599 integer) (raw)) => 0
run: empty?/read/read-rank/read-move 2: 0 => ((4 integer))
mem: ((4 integer)): 101602 <= 0
run: empty?/read/read-rank/read-move 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
mem: ((101600 integer) (raw)) => 0
run: empty?/read/read-rank/read-move 3: 0 => ((5 integer))
mem: ((5 integer)): 101603 <= 0
run: empty?/read/read-rank/read-move 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
mem: ((4 integer)) => 0
mem: ((5 integer)) => 0
run: empty?/read/read-rank/read-move 4: t => ((6 boolean))
mem: ((6 boolean)): 101604 <= t
run: empty?/read/read-rank/read-move 5: (((reply)) ((6 boolean)))
mem: ((6 boolean)) => t
run: read/read-rank/read-move 2: t => ((2 boolean))
mem: ((2 boolean)): 101569 <= t
run: read/read-rank/read-move 3: (((jump-unless)) ((2 boolean)) ((2 offset)))
mem: ((2 boolean)) => t
run: read/read-rank/read-move 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
run: read/read-rank/read-move 4: 1063 => ((3 integer-address))
mem: ((3 integer-address)): 101570 <= 1063
run: read/read-rank/read-move 5: (((sleep)) ((until-location-changes literal)) ((3 integer-address) (deref)))
mem: ((3 integer-address) (deref)) => 0
schedule: pushing read/read-rank/read-move to sleep queue
schedule: waking up write/main
schedule: write/main
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
mem: ((1064 tagged-value-array-address) (raw)) => 1065
run: write/main 7: 1065 => ((6 tagged-value-array-address))
mem: ((6 tagged-value-array-address)): 1449 <= 1065
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
run: write/main 8: 1063 => ((7 integer-address))
mem: ((7 integer-address)): 1450 <= 1063
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
mem: ((7 integer-address) (deref)) => 0
array-len: ((1065 tagged-value-array) (raw))
mem: ((1065 integer) (raw)) => 2
run: write/main 9: 1066 => ((8 tagged-value-address))
mem: ((8 tagged-value-address)): 1451 <= 1066
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
mem: ((2 tagged-value)) => #(tagged record (character 4 . nil))
run: write/main 10: #(tagged record (character #\4 . nil)) => ((8 tagged-value-address) (deref))
mem: ((8 tagged-value-address) (deref)): 1066 <= character
mem: ((8 tagged-value-address) (deref)): 1067 <= #\4
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
mem: ((7 integer-address) (deref)) => 0
run: write/main 11: 1 => ((7 integer-address) (deref))
mem: ((7 integer-address) (deref)): 1063 <= 1
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
array-len: ((6 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: write/main 12: 2 => ((9 integer))
mem: ((9 integer)): 1452 <= 2
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
mem: ((7 integer-address) (deref)) => 1
mem: ((9 integer)) => 2
run: write/main 13: t => ((10 boolean))
mem: ((10 boolean)): 1453 <= t
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
mem: ((10 boolean)) => t
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 1 1065 . nil))
run: main 17: #(tagged record (0 1 1065 . nil)) => ((1 channel-address) (deref))
mem: ((1 channel-address) (deref)): 1062 <= 0
mem: ((1 channel-address) (deref)): 1063 <= 1
mem: ((1 channel-address) (deref)): 1064 <= 1065
run: main 18: (((3 character)) <- ((copy)) ((
 literal)))
run: main 18: #\newline => ((3 character))
mem: ((3 character)): 1004 <= #\newline
run: main 19: (((4 tagged-value)) <- ((save-type)) ((3 character)))
mem: ((3 character)) => 

run: main 19: #(tagged record (character #\newline)) => ((4 tagged-value))
mem: ((4 tagged-value)): 1005 <= character
mem: ((4 tagged-value)): 1006 <= #\newline
run: main 20: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((4 tagged-value)))
mem: ((1 channel-address)) => 1062
mem: ((4 tagged-value)) => #(tagged record (character 
 . nil))
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: write/main 0: 1535 => ((default-space space-address))
run: write/main 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062 #(tagged record (character #\newline . nil)))
run: write/main 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 1537 <= 1062
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
arg: nil 1 (1062 #(tagged record (character #\newline . nil)))
run: write/main 2: #(tagged record (character #\newline . nil)) => ((2 tagged-value))
mem: ((2 tagged-value)): 1538 <= character
mem: ((2 tagged-value)): 1539 <= #\newline
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
mem: ((1 channel-address) (deref)) => #(tagged record (0 1 1065 . nil))
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: full?/write/main 0: 1566 => ((default-space space-address))
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (0 1 1065 . nil)))
run: full?/write/main 1: #(tagged record (0 1 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 1568 <= 0
mem: ((1 channel)): 1569 <= 1
mem: ((1 channel)): 1570 <= 1065
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
mem: ((1569 integer) (raw)) => 1
run: full?/write/main 2: 1 => ((4 integer))
mem: ((4 integer)): 1571 <= 1
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
mem: ((4 integer)) => 1
run: full?/write/main 3: 2 => ((4 integer))
mem: ((4 integer)): 1571 <= 2
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
mem: ((1 channel)) => #(tagged record (0 1 1065 . nil))
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: capacity/full?/write/main 0: 1597 => ((default-space space-address))
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (0 1 1065 . nil)))
run: capacity/full?/write/main 1: #(tagged record (0 1 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 1599 <= 0
mem: ((1 channel)): 1600 <= 1
mem: ((1 channel)): 1601 <= 1065
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
mem: ((1601 tagged-value-array-address) (raw)) => 1065
run: capacity/full?/write/main 2: 1065 => ((4 tagged-value-array-address))
mem: ((4 tagged-value-array-address)): 1602 <= 1065
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
array-len: ((4 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: capacity/full?/write/main 3: 2 => ((5 integer))
mem: ((5 integer)): 1603 <= 2
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
mem: ((5 integer)) => 2
run: full?/write/main 4: 2 => ((5 integer))
mem: ((5 integer)): 1572 <= 2
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
mem: ((4 integer)) => 2
mem: ((5 integer)) => 2
run: full?/write/main 5: nil => ((6 boolean))
mem: ((6 boolean)): 1573 <= nil
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
mem: ((6 boolean)) => nil
run: full?/write/main 7: (((4 integer)) <- ((copy)) ((0 literal)))
run: full?/write/main 7: 0 => ((4 integer))
mem: ((4 integer)): 1571 <= 0
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
mem: ((1568 integer) (raw)) => 0
run: full?/write/main 8: 0 => ((7 integer))
mem: ((7 integer)): 1574 <= 0
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
mem: ((7 integer)) => 0
mem: ((4 integer)) => 0
run: full?/write/main 9: t => ((8 boolean))
mem: ((8 boolean)): 1575 <= t
run: full?/write/main 10: (((reply)) ((8 boolean)))
mem: ((8 boolean)) => t
run: write/main 3: t => ((4 boolean))
mem: ((4 boolean)): 1540 <= t
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
mem: ((4 boolean)) => t
run: write/main 5: (((5 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
run: write/main 5: 1062 => ((5 integer-address))
mem: ((5 integer-address)): 1541 <= 1062
run: write/main 6: (((sleep)) ((until-location-changes literal)) ((5 integer-address) (deref)))
mem: ((5 integer-address) (deref)) => 0
schedule: pushing write/main to sleep queue
schedule: waking up read/read-rank/read-move
schedule: read/read-rank/read-move
run: read/read-rank/read-move 6: (((4 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
run: read/read-rank/read-move 6: 1062 => ((4 integer-address))
mem: ((4 integer-address)): 101571 <= 1062
run: read/read-rank/read-move 7: (((5 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
mem: ((1064 tagged-value-array-address) (raw)) => 1065
run: read/read-rank/read-move 7: 1065 => ((5 tagged-value-array-address))
mem: ((5 tagged-value-array-address)): 101572 <= 1065
run: read/read-rank/read-move 8: (((6 tagged-value)) <- ((index)) ((5 tagged-value-array-address) (deref)) ((4 integer-address) (deref)))
mem: ((4 integer-address) (deref)) => 0
array-len: ((1065 tagged-value-array) (raw))
mem: ((1065 integer) (raw)) => 2
mem: ((1066 tagged-value) (raw)) => #(tagged record (character 4 . nil))
run: read/read-rank/read-move 8: #(tagged record (character #\4 . nil)) => ((6 tagged-value))
mem: ((6 tagged-value)): 101573 <= character
mem: ((6 tagged-value)): 101574 <= #\4
run: read/read-rank/read-move 9: (((4 integer-address) (deref)) <- ((add)) ((4 integer-address) (deref)) ((1 literal)))
mem: ((4 integer-address) (deref)) => 0
run: read/read-rank/read-move 9: 1 => ((4 integer-address) (deref))
mem: ((4 integer-address) (deref)): 1062 <= 1
run: read/read-rank/read-move 10: (((8 integer)) <- ((length)) ((5 tagged-value-array-address) (deref)))
array-len: ((5 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: read/read-rank/read-move 10: 2 => ((8 integer))
mem: ((8 integer)): 101575 <= 2
run: read/read-rank/read-move 11: (((9 boolean)) <- ((less-than)) ((4 integer-address) (deref)) ((8 integer)))
mem: ((4 integer-address) (deref)) => 1
mem: ((8 integer)) => 2
run: read/read-rank/read-move 11: t => ((9 boolean))
mem: ((9 boolean)): 101576 <= t
run: read/read-rank/read-move 12: (((jump-if)) ((9 boolean)) ((1 offset)))
mem: ((9 boolean)) => t
run: read/read-rank/read-move 14: (((reply)) ((6 tagged-value)) ((1 channel-address) (deref) (same-as-arg 0)))
mem: ((6 tagged-value)) => #(tagged record (character 4 . nil))
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (1 1 1065 . nil))
run: read-rank/read-move 2: #(tagged record (character #\4 . nil)) => ((2 tagged-value))
mem: ((2 tagged-value)): 101538 <= character
mem: ((2 tagged-value)): 101539 <= #\4
run: read-rank/read-move 2: #(tagged record (1 1 1065 . nil)) => ((1 channel-address) (deref))
mem: ((1 channel-address) (deref)): 1062 <= 1
mem: ((1 channel-address) (deref)): 1063 <= 1
mem: ((1 channel-address) (deref)): 1064 <= 1065
run: read-rank/read-move 3: (((4 character)) <- ((maybe-coerce)) ((2 tagged-value)) ((character literal)))
mem: ((2 tagged-value)) => #(tagged record (character 4 . nil))
run: maybe-coerce/read-rank/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: maybe-coerce/read-rank/read-move 0: 101628 => ((default-space space-address))
run: maybe-coerce/read-rank/read-move 1: (((1 tagged-value-address)) <- ((new)) ((tagged-value literal)))
run: maybe-coerce/read-rank/read-move 1: 101659 => ((1 tagged-value-address))
mem: ((1 tagged-value-address)): 101630 <= 101659
run: maybe-coerce/read-rank/read-move 2: (((1 tagged-value-address) (deref)) <- ((next-input)))
arg: nil 0 (#(tagged record (character #\4 . nil)) character)
run: maybe-coerce/read-rank/read-move 2: #(tagged record (character #\4 . nil)) => ((1 tagged-value-address) (deref))
mem: ((1 tagged-value-address) (deref)): 101659 <= character
mem: ((1 tagged-value-address) (deref)): 101660 <= #\4
run: maybe-coerce/read-rank/read-move 3: (((2 type)) <- ((next-input)))
arg: nil 1 (#(tagged record (character #\4 . nil)) character)
run: maybe-coerce/read-rank/read-move 3: character => ((2 type))
mem: ((2 type)): 101631 <= character
run: maybe-coerce/read-rank/read-move 4: (((3 type)) <- ((get)) ((1 tagged-value-address) (deref)) ((0 offset)))
mem: ((101659 type) (raw)) => character
run: maybe-coerce/read-rank/read-move 4: character => ((3 type))
mem: ((3 type)): 101632 <= character
run: maybe-coerce/read-rank/read-move 5: (((4 boolean)) <- ((equal)) ((3 type)) ((2 type)))
mem: ((3 type)) => character
mem: ((2 type)) => character
run: maybe-coerce/read-rank/read-move 5: t => ((4 boolean))
mem: ((4 boolean)): 101633 <= t
run: maybe-coerce/read-rank/read-move 6: (((jump-if)) ((4 boolean)) ((1 offset)))
mem: ((4 boolean)) => t
run: maybe-coerce/read-rank/read-move 8: (((5 location)) <- ((get)) ((1 tagged-value-address) (deref)) ((1 offset)))
mem: ((101660 location) (raw)) => 4
run: maybe-coerce/read-rank/read-move 8: #\4 => ((5 location))
mem: ((5 location)): 101634 <= #\4
run: maybe-coerce/read-rank/read-move 9: (((reply)) ((5 location)) ((4 boolean)))
mem: ((5 location)) => 4
mem: ((4 boolean)) => t
run: read-rank/read-move 3: #\4 => ((4 character))
mem: ((4 character)): 101540 <= #\4
run: read-rank/read-move 4: (((5 boolean)) <- ((equal)) ((4 character)) ((q literal)))
mem: ((4 character)) => 4
run: read-rank/read-move 4: nil => ((5 boolean))
mem: ((5 boolean)): 101541 <= nil
run: read-rank/read-move 5: (((jump-unless)) ((5 boolean)) ((1 offset)))
mem: ((5 boolean)) => nil
run: read-rank/read-move 7: (((6 integer)) <- ((character-to-integer)) ((4 character)))
mem: ((4 character)) => 4
run: read-rank/read-move 7: 52 => ((6 integer))
mem: ((6 integer)): 101542 <= 52
run: read-rank/read-move 8: (((7 character)) <- ((copy)) ((1 literal)))
run: read-rank/read-move 8: #\1 => ((7 character))
mem: ((7 character)): 101543 <= #\1
run: read-rank/read-move 9: (((8 integer)) <- ((character-to-integer)) ((7 character)))
mem: ((7 character)) => 1
run: read-rank/read-move 9: 49 => ((8 integer))
mem: ((8 integer)): 101544 <= 49
run: read-rank/read-move 10: (((6 integer)) <- ((subtract)) ((6 integer)) ((8 integer)))
mem: ((6 integer)) => 52
mem: ((8 integer)) => 49
run: read-rank/read-move 10: 3 => ((6 integer))
mem: ((6 integer)): 101542 <= 3
run: read-rank/read-move 11: (((9 boolean)) <- ((greater-or-equal)) ((6 integer)) ((0 literal)))
mem: ((6 integer)) => 3
run: read-rank/read-move 11: t => ((9 boolean))
mem: ((9 boolean)): 101545 <= t
run: read-rank/read-move 12: (((assert)) ((9 boolean)) ((rank too low literal)))
mem: ((9 boolean)) => t
run: read-rank/read-move 13: (((10 boolean)) <- ((lesser-or-equal)) ((6 integer)) ((7 literal)))
mem: ((6 integer)) => 3
run: read-rank/read-move 13: t => ((10 boolean))
mem: ((10 boolean)): 101546 <= t
run: read-rank/read-move 14: (((assert)) ((10 boolean)) ((rank too high literal)))
mem: ((10 boolean)) => t
run: read-rank/read-move 15: (((reply)) ((6 integer)))
mem: ((6 integer)) => 3
run: read-move 8: 3 => ((5 integer))
mem: ((5 integer)): 101006 <= 3
run: read-move 9: (((expect-stdin)) ((1 channel-address)) ((
 literal)))
mem: ((1 channel-address)) => 1062
run: expect-stdin/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: expect-stdin/read-move 0: 101661 => ((default-space space-address))
run: expect-stdin/read-move 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062 #\newline)
run: expect-stdin/read-move 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 101663 <= 1062
run: expect-stdin/read-move 2: (((2 tagged-value)) ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
mem: ((1 channel-address)) => 1062
run: read/expect-stdin/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: read/expect-stdin/read-move 0: 101692 => ((default-space space-address))
run: read/expect-stdin/read-move 1: (((1 channel-address)) <- ((next-input)))
arg: nil 0 (1062)
run: read/expect-stdin/read-move 1: 1062 => ((1 channel-address))
mem: ((1 channel-address)): 101694 <= 1062
run: read/expect-stdin/read-move 2: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
mem: ((1 channel-address) (deref)) => #(tagged record (1 1 1065 . nil))
run: empty?/read/expect-stdin/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: empty?/read/expect-stdin/read-move 0: 101723 => ((default-space space-address))
run: empty?/read/expect-stdin/read-move 1: (((1 channel)) <- ((next-input)))
arg: nil 0 (#(tagged record (1 1 1065 . nil)))
run: empty?/read/expect-stdin/read-move 1: #(tagged record (1 1 1065 . nil)) => ((1 channel))
mem: ((1 channel)): 101725 <= 1
mem: ((1 channel)): 101726 <= 1
mem: ((1 channel)): 101727 <= 1065
run: empty?/read/expect-stdin/read-move 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
mem: ((101725 integer) (raw)) => 1
run: empty?/read/expect-stdin/read-move 2: 1 => ((4 integer))
mem: ((4 integer)): 101728 <= 1
run: empty?/read/expect-stdin/read-move 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
mem: ((101726 integer) (raw)) => 1
run: empty?/read/expect-stdin/read-move 3: 1 => ((5 integer))
mem: ((5 integer)): 101729 <= 1
run: empty?/read/expect-stdin/read-move 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
mem: ((4 integer)) => 1
mem: ((5 integer)) => 1
run: empty?/read/expect-stdin/read-move 4: t => ((6 boolean))
mem: ((6 boolean)): 101730 <= t
run: empty?/read/expect-stdin/read-move 5: (((reply)) ((6 boolean)))
mem: ((6 boolean)) => t
run: read/expect-stdin/read-move 2: t => ((2 boolean))
mem: ((2 boolean)): 101695 <= t
run: read/expect-stdin/read-move 3: (((jump-unless)) ((2 boolean)) ((2 offset)))
mem: ((2 boolean)) => t
run: read/expect-stdin/read-move 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
run: read/expect-stdin/read-move 4: 1063 => ((3 integer-address))
mem: ((3 integer-address)): 101696 <= 1063
run: read/expect-stdin/read-move 5: (((sleep)) ((until-location-changes literal)) ((3 integer-address) (deref)))
mem: ((3 integer-address) (deref)) => 1
schedule: pushing read/expect-stdin/read-move to sleep queue
schedule: waking up write/main
schedule: write/main
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
mem: ((1064 tagged-value-array-address) (raw)) => 1065
run: write/main 7: 1065 => ((6 tagged-value-array-address))
mem: ((6 tagged-value-array-address)): 1542 <= 1065
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
run: write/main 8: 1063 => ((7 integer-address))
mem: ((7 integer-address)): 1543 <= 1063
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
mem: ((7 integer-address) (deref)) => 1
array-len: ((1065 tagged-value-array) (raw))
mem: ((1065 integer) (raw)) => 2
run: write/main 9: 1068 => ((8 tagged-value-address))
mem: ((8 tagged-value-address)): 1544 <= 1068
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
mem: ((2 tagged-value)) => #(tagged record (character 
 . nil))
run: write/main 10: #(tagged record (character #\newline . nil)) => ((8 tagged-value-address) (deref))
mem: ((8 tagged-value-address) (deref)): 1068 <= character
mem: ((8 tagged-value-address) (deref)): 1069 <= #\newline
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
mem: ((7 integer-address) (deref)) => 1
run: write/main 11: 2 => ((7 integer-address) (deref))
mem: ((7 integer-address) (deref)): 1063 <= 2
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
array-len: ((6 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: write/main 12: 2 => ((9 integer))
mem: ((9 integer)): 1545 <= 2
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
mem: ((7 integer-address) (deref)) => 2
mem: ((9 integer)) => 2
run: write/main 13: nil => ((10 boolean))
mem: ((10 boolean)): 1546 <= nil
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
mem: ((10 boolean)) => nil
run: write/main 15: (((7 integer-address) (deref)) <- ((copy)) ((0 literal)))
run: write/main 15: 0 => ((7 integer-address) (deref))
mem: ((7 integer-address) (deref)): 1063 <= 0
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (1 0 1065 . nil))
run: main 20: #(tagged record (1 0 1065 . nil)) => ((1 channel-address) (deref))
mem: ((1 channel-address) (deref)): 1062 <= 1
mem: ((1 channel-address) (deref)): 1063 <= 0
mem: ((1 channel-address) (deref)): 1064 <= 1065
run: main 21: (((sleep)) ((until-routine-done literal)) ((2 integer) (routine)))
mem: ((2 integer) (routine)) => 1
schedule: pushing main to sleep queue
schedule: waking up read/expect-stdin/read-move
schedule: read/expect-stdin/read-move
run: read/expect-stdin/read-move 6: (((4 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
run: read/expect-stdin/read-move 6: 1062 => ((4 integer-address))
mem: ((4 integer-address)): 101697 <= 1062
run: read/expect-stdin/read-move 7: (((5 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
mem: ((1064 tagged-value-array-address) (raw)) => 1065
run: read/expect-stdin/read-move 7: 1065 => ((5 tagged-value-array-address))
mem: ((5 tagged-value-array-address)): 101698 <= 1065
run: read/expect-stdin/read-move 8: (((6 tagged-value)) <- ((index)) ((5 tagged-value-array-address) (deref)) ((4 integer-address) (deref)))
mem: ((4 integer-address) (deref)) => 1
array-len: ((1065 tagged-value-array) (raw))
mem: ((1065 integer) (raw)) => 2
mem: ((1068 tagged-value) (raw)) => #(tagged record (character 
 . nil))
run: read/expect-stdin/read-move 8: #(tagged record (character #\newline . nil)) => ((6 tagged-value))
mem: ((6 tagged-value)): 101699 <= character
mem: ((6 tagged-value)): 101700 <= #\newline
run: read/expect-stdin/read-move 9: (((4 integer-address) (deref)) <- ((add)) ((4 integer-address) (deref)) ((1 literal)))
mem: ((4 integer-address) (deref)) => 1
run: read/expect-stdin/read-move 9: 2 => ((4 integer-address) (deref))
mem: ((4 integer-address) (deref)): 1062 <= 2
run: read/expect-stdin/read-move 10: (((8 integer)) <- ((length)) ((5 tagged-value-array-address) (deref)))
array-len: ((5 tagged-value-array-address) (deref))
mem: ((1065 integer) (raw)) => 2
run: read/expect-stdin/read-move 10: 2 => ((8 integer))
mem: ((8 integer)): 101701 <= 2
run: read/expect-stdin/read-move 11: (((9 boolean)) <- ((less-than)) ((4 integer-address) (deref)) ((8 integer)))
mem: ((4 integer-address) (deref)) => 2
mem: ((8 integer)) => 2
run: read/expect-stdin/read-move 11: nil => ((9 boolean))
mem: ((9 boolean)): 101702 <= nil
run: read/expect-stdin/read-move 12: (((jump-if)) ((9 boolean)) ((1 offset)))
mem: ((9 boolean)) => nil
run: read/expect-stdin/read-move 13: (((4 integer-address) (deref)) <- ((copy)) ((0 literal)))
run: read/expect-stdin/read-move 13: 0 => ((4 integer-address) (deref))
mem: ((4 integer-address) (deref)): 1062 <= 0
run: read/expect-stdin/read-move 14: (((reply)) ((6 tagged-value)) ((1 channel-address) (deref) (same-as-arg 0)))
mem: ((6 tagged-value)) => #(tagged record (character 
 . nil))
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 0 1065 . nil))
run: expect-stdin/read-move 2: #(tagged record (character #\newline . nil)) => ((2 tagged-value))
mem: ((2 tagged-value)): 101664 <= character
mem: ((2 tagged-value)): 101665 <= #\newline
run: expect-stdin/read-move 2: #(tagged record (0 0 1065 . nil)) => ((1 channel-address) (deref))
mem: ((1 channel-address) (deref)): 1062 <= 0
mem: ((1 channel-address) (deref)): 1063 <= 0
mem: ((1 channel-address) (deref)): 1064 <= 1065
run: expect-stdin/read-move 3: (((4 character)) <- ((maybe-coerce)) ((2 tagged-value)) ((character literal)))
mem: ((2 tagged-value)) => #(tagged record (character 
 . nil))
run: maybe-coerce/expect-stdin/read-move 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
run: maybe-coerce/expect-stdin/read-move 0: 101754 => ((default-space space-address))
run: maybe-coerce/expect-stdin/read-move 1: (((1 tagged-value-address)) <- ((new)) ((tagged-value literal)))
run: maybe-coerce/expect-stdin/read-move 1: 101785 => ((1 tagged-value-address))
mem: ((1 tagged-value-address)): 101756 <= 101785
run: maybe-coerce/expect-stdin/read-move 2: (((1 tagged-value-address) (deref)) <- ((next-input)))
arg: nil 0 (#(tagged record (character #\newline . nil)) character)
run: maybe-coerce/expect-stdin/read-move 2: #(tagged record (character #\newline . nil)) => ((1 tagged-value-address) (deref))
mem: ((1 tagged-value-address) (deref)): 101785 <= character
mem: ((1 tagged-value-address) (deref)): 101786 <= #\newline
run: maybe-coerce/expect-stdin/read-move 3: (((2 type)) <- ((next-input)))
arg: nil 1 (#(tagged record (character #\newline . nil)) character)
run: maybe-coerce/expect-stdin/read-move 3: character => ((2 type))
mem: ((2 type)): 101757 <= character
run: maybe-coerce/expect-stdin/read-move 4: (((3 type)) <- ((get)) ((1 tagged-value-address) (deref)) ((0 offset)))
mem: ((101785 type) (raw)) => character
run: maybe-coerce/expect-stdin/read-move 4: character => ((3 type))
mem: ((3 type)): 101758 <= character
run: maybe-coerce/expect-stdin/read-move 5: (((4 boolean)) <- ((equal)) ((3 type)) ((2 type)))
mem: ((3 type)) => character
mem: ((2 type)) => character
run: maybe-coerce/expect-stdin/read-move 5: t => ((4 boolean))
mem: ((4 boolean)): 101759 <= t
run: maybe-coerce/expect-stdin/read-move 6: (((jump-if)) ((4 boolean)) ((1 offset)))
mem: ((4 boolean)) => t
run: maybe-coerce/expect-stdin/read-move 8: (((5 location)) <- ((get)) ((1 tagged-value-address) (deref)) ((1 offset)))
mem: ((101786 location) (raw)) => 

run: maybe-coerce/expect-stdin/read-move 8: #\newline => ((5 location))
mem: ((5 location)): 101760 <= #\newline
run: maybe-coerce/expect-stdin/read-move 9: (((reply)) ((5 location)) ((4 boolean)))
mem: ((5 location)) => 

mem: ((4 boolean)) => t
run: expect-stdin/read-move 3: #\newline => ((4 character))
mem: ((4 character)): 101666 <= #\newline
run: expect-stdin/read-move 4: (((5 character)) <- ((next-input)))
arg: nil 1 (1062 #\newline)
run: expect-stdin/read-move 4: #\newline => ((5 character))
mem: ((5 character)): 101667 <= #\newline
run: expect-stdin/read-move 5: (((6 boolean)) <- ((equal)) ((4 character)) ((5 character)))
mem: ((4 character)) => 

mem: ((5 character)) => 

run: expect-stdin/read-move 5: t => ((6 boolean))
mem: ((6 boolean)): 101668 <= t
run: expect-stdin/read-move 6: (((assert)) ((6 boolean)) ((expected character not found literal)))
mem: ((6 boolean)) => t
run: read-move 10: (((6 move-address)) <- ((new)) ((move literal)))
run: read-move 10: 101787 => ((6 move-address))
mem: ((6 move-address)): 101007 <= 101787
run: read-move 11: (((7 integer-integer-pair-address)) <- ((get-address)) ((6 move-address) (deref)) ((0 offset)))
run: read-move 11: 101787 => ((7 integer-integer-pair-address))
mem: ((7 integer-integer-pair-address)): 101008 <= 101787
run: read-move 12: (((8 integer-address)) <- ((get-address)) ((7 integer-integer-pair-address) (deref)) ((0 offset)))
run: read-move 12: 101787 => ((8 integer-address))
mem: ((8 integer-address)): 101009 <= 101787
run: read-move 13: (((8 integer-address) (deref)) <- ((copy)) ((2 integer)))
mem: ((2 integer)) => 0
run: read-move 13: 0 => ((8 integer-address) (deref))
mem: ((8 integer-address) (deref)): 101787 <= 0
run: read-move 14: (((8 integer-address)) <- ((get-address)) ((7 integer-integer-pair-address) (deref)) ((1 offset)))
run: read-move 14: 101788 => ((8 integer-address))
mem: ((8 integer-address)): 101009 <= 101788
run: read-move 15: (((8 integer-address) (deref)) <- ((copy)) ((3 integer)))
mem: ((3 integer)) => 1
run: read-move 15: 1 => ((8 integer-address) (deref))
mem: ((8 integer-address) (deref)): 101788 <= 1
run: read-move 16: (((9 integer-integer-pair-address)) <- ((get-address)) ((6 move-address) (deref)) ((1 offset)))
run: read-move 16: 101789 => ((9 integer-integer-pair-address))
mem: ((9 integer-integer-pair-address)): 101010 <= 101789
run: read-move 17: (((8 integer-address)) <- ((get-address)) ((9 integer-integer-pair-address) (deref)) ((0 offset)))
run: read-move 17: 101789 => ((8 integer-address))
mem: ((8 integer-address)): 101009 <= 101789
run: read-move 18: (((8 integer-address) (deref)) <- ((copy)) ((4 integer)))
mem: ((4 integer)) => 0
run: read-move 18: 0 => ((8 integer-address) (deref))
mem: ((8 integer-address) (deref)): 101789 <= 0
run: read-move 19: (((8 integer-address)) <- ((get-address)) ((9 integer-integer-pair-address) (deref)) ((1 offset)))
run: read-move 19: 101790 => ((8 integer-address))
mem: ((8 integer-address)): 101009 <= 101790
run: read-move 20: (((8 integer-address) (deref)) <- ((copy)) ((5 integer)))
mem: ((5 integer)) => 3
run: read-move 20: 3 => ((8 integer-address) (deref))
mem: ((8 integer-address) (deref)): 101790 <= 3
run: read-move 21: (((reply)) ((6 move-address)))
mem: ((6 move-address)) => 101787
schedule: done with routine nil
schedule: waking up main
schedule: main
schedule: done with routine nil