6158 - standardize opcode names

At the lowest level, SubX without syntax sugar uses names without prepositions.
For example, 01 and 03 are both called 'add', irrespective of source and
destination operand. Horizontal space is at a premium, and we rely on the
comments at the end of each line to fully describe what is happening.

Above that, however, we standardize on a slightly different naming convention
across:
  a) SubX with syntax sugar,
  b) Mu, and
  c) the SubX code that the Mu compiler emits.

Conventions, in brief:
  - by default, the source is on the left and destination on the right.
    e.g. add %eax, 1/r32/ecx ("add eax to ecx")
  - prepositions reverse the direction.
    e.g. add-to %eax, 1/r32/ecx ("add ecx to eax")
         subtract-from %eax, 1/r32/ecx ("subtract ecx from eax")
  - by default, comparisons are left to right while 'compare<-' reverses.

Before, I was sometimes swapping args to make the operation more obvious,
but that would complicate the code-generation of the Mu compiler, and it's
nice to be able to read the output of the compiler just like hand-written
code.

One place where SubX differs from Mu: copy opcodes are called '<-' and
'->'. Hopefully that fits with the spirit of Mu rather than the letter
of the 'copy' and 'copy-to' instructions.

5 files changed, 87 insertions, 107 deletions

diff --git a/100array-equal.subx b/100array-equal.subx
index c6e03bf2..ca222619 100644
--- a/100array-equal.subx
+++ b/100array-equal.subx
@@ -48,7 +48,7 @@ $array-equal?:lengths:
     # var currb/edi: (addr byte) = b->data
     81 0/subop/add %edi 4/imm32
     # var i/ecx: int = 0
-    31/xor %ecx 1/r32/ecx
+    31/xor-with %ecx 1/r32/ecx
     # var vala/eax: int
     # var valb/ebx: int
 $array-equal?:loop:
@@ -213,9 +213,9 @@ parse-array-of-ints:  # ad: (addr allocation-descriptor), s: (addr string) -> re
     # . edx = s->length
     8b/-> *esi 2/r32/edx
     # . edx += curr
-    01/add %edx 1/r32/ecx
+    01/add-to %edx 1/r32/ecx
     # var size/ebx: int = 0
-    31/xor %ebx 3/r32/ebx
+    31/xor-with %ebx 3/r32/ebx
 $parse-array-of-ints:loop1:
     # if (curr >= end) break
     39/compare %ecx 2/r32/edx
@@ -235,7 +235,7 @@ $parse-array-of-ints:loop1:
 $parse-array-of-ints:break1:
     # var result/edi: (handle array int)
     89/<- %eax 3/r32/ebx
-    05/add-eax 4/imm32
+    05/add-to-eax 4/imm32
     (allocate *(ebp+8) %eax)
     89/<- %edi 0/r32/eax
     # result->size = size
diff --git a/apps/calls.subx b/apps/calls.subx
index cc468d3b..16ca8dc8 100644
--- a/apps/calls.subx
+++ b/apps/calls.subx
@@ -149,7 +149,7 @@ $subx-calls:check0:
     # . ecx = line->read
     8b/-> *(esi+4) 1/r32/ecx
     # . eax = line->data[line->read]
-    31/xor %eax 0/r32/eax
+    31/xor-with %eax 0/r32/eax
     8a/copy-byte *(esi+ecx+0xc) 0/r32/AL
     # . if (eax == '(') goto convert-call
     3d/compare-eax-and 0x28/imm32/open-paren
@@ -824,7 +824,7 @@ $next-word-string-or-expression-without-metadata:check0:
     # . ecx = line->read
     8b/-> *(esi+4) 1/r32/ecx
     # . if (ecx >= line->write) abort
-    3b/compare 1/r32/ecx *esi
+    3b/compare<- *esi 1/r32/ecx
     0f 8d/jump-if->= $next-word-string-or-expression-without-metadata:error0/disp32
 $next-word-string-or-expression-without-metadata:check-for-comment:
     # out->start = &line->data[line->read]
@@ -832,7 +832,7 @@ $next-word-string-or-expression-without-metadata:check-for-comment:
     89/<- *edi 0/r32/eax
     # if (line->data[line->read] != '#') goto next check
     # . var eax: byte = line->data[line->read]
-    31/xor %eax 0/r32/eax
+    31/xor-with %eax 0/r32/eax
     8a/copy-byte *(esi+ecx+0xc) 0/r32/AL
     # . if (eax != '#') goto next check
     3d/compare-eax-and 0x23/imm32/pound
@@ -910,7 +910,7 @@ $next-word-string-or-expression-without-metadata:check-for-end-of-call:
     # . ecx = line->read
     8b/-> *(esi+4) 1/r32/ecx
     # . if (ecx >= line->write) return {0, 0}
-    3b/compare 1/r32/ecx *esi
+    3b/compare<- *esi 1/r32/ecx
     0f 8d/jump-if->= $next-word-string-or-expression-without-metadata:return-eol/disp32
     # if (line->data[line->read] == '/') goto error3
     # . eax = line->data[line->read]
@@ -929,7 +929,7 @@ $next-word-string-or-expression-without-metadata:check-for-end-of-call:
     # . ecx = line->read
     8b/-> *(esi+4) 1/r32/ecx
     # . if (ecx >= line->write) return {0, 0}
-    3b/compare 1/r32/ecx *esi
+    3b/compare<- *esi 1/r32/ecx
     0f 8d/jump-if->= $next-word-string-or-expression-without-metadata:return-eol/disp32
     # if (line->data[line->read] == '#') return out = {0, 0}
     # . eax = line->data[line->read]
@@ -945,7 +945,7 @@ $next-word-string-or-expression-without-metadata:regular-word-without-metadata:
     # . ecx = line->read
     8b/-> *(esi+4) 1/r32/ecx
     # . if (ecx >= line->write) break
-    3b/compare *esi 1/r32/ecx
+    3b/compare<- *esi 1/r32/ecx
     7d/jump-if->= $next-word-string-or-expression-without-metadata:regular-word-break/disp8
     # if (line->data[line->read] == ' ') break
     # . eax = line->data[line->read]
diff --git a/apps/mu b/apps/mu
index 7b923ee9..0e21e322 100755
--- a/apps/mu
+++ b/apps/mu
Binary files differdiff --git a/apps/mu.subx b/apps/mu.subx
index f78f6bbb..5ab9e8af 100644
--- a/apps/mu.subx
+++ b/apps/mu.subx
@@ -736,7 +736,7 @@ test-convert-function-returns-result:
     (check-next-stream-line-equal _test-output-stream "  89/<- %ebp 4/r32/esp"  "F - test-convert-function-returns-result/3")
     (check-next-stream-line-equal _test-output-stream "  {"                     "F - test-convert-function-returns-result/4")
     (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:"   "F - test-convert-function-returns-result/5")
-    (check-next-stream-line-equal _test-output-stream "    8b/copy-from *(ebp+0x00000008) 0x00000000/r32"  "F - test-convert-function-returns-result/6")
+    (check-next-stream-line-equal _test-output-stream "    8b/-> *(ebp+0x00000008) 0x00000000/r32"  "F - test-convert-function-returns-result/6")
     (check-next-stream-line-equal _test-output-stream "    40/increment-eax"    "F - test-convert-function-returns-result/7")
     (check-next-stream-line-equal _test-output-stream "  }"                     "F - test-convert-function-returns-result/8")
     (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:"  "F - test-convert-function-returns-result/9")
@@ -779,7 +779,7 @@ test-convert-function-with-literal-arg:
     (check-next-stream-line-equal _test-output-stream "  89/<- %ebp 4/r32/esp"  "F - test-convert-function-with-literal-arg/3")
     (check-next-stream-line-equal _test-output-stream "  {"                     "F - test-convert-function-with-literal-arg/4")
     (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:"   "F - test-convert-function-with-literal-arg/5")
-    (check-next-stream-line-equal _test-output-stream "    8b/copy-from *(ebp+0x00000008) 0x00000000/r32"  "F - test-convert-function-with-literal-arg/6")
+    (check-next-stream-line-equal _test-output-stream "    8b/-> *(ebp+0x00000008) 0x00000000/r32"  "F - test-convert-function-with-literal-arg/6")
     (check-next-stream-line-equal _test-output-stream "    05/add-to-eax 1/imm32"  "F - test-convert-function-with-literal-arg/7")
     (check-next-stream-line-equal _test-output-stream "  }"                     "F - test-convert-function-with-literal-arg/8")
     (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:"  "F - test-convert-function-with-literal-arg/9")
@@ -822,7 +822,7 @@ test-convert-function-with-literal-arg-2:
     (check-next-stream-line-equal _test-output-stream "  89/<- %ebp 4/r32/esp"  "F - test-convert-function-with-literal-arg-2/3")
     (check-next-stream-line-equal _test-output-stream "  {"                     "F - test-convert-function-with-literal-arg-2/4")
     (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:"   "F - test-convert-function-with-literal-arg-2/5")
-    (check-next-stream-line-equal _test-output-stream "    8b/copy-from *(ebp+0x00000008) 0x00000003/r32"  "F - test-convert-function-with-literal-arg-2/6")
+    (check-next-stream-line-equal _test-output-stream "    8b/-> *(ebp+0x00000008) 0x00000003/r32"  "F - test-convert-function-with-literal-arg-2/6")
     (check-next-stream-line-equal _test-output-stream "    81 0/subop/add %ebx 1/imm32"  "F - test-convert-function-with-literal-arg-2/7")
     (check-next-stream-line-equal _test-output-stream "  }"                     "F - test-convert-function-with-literal-arg-2/8")
     (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:"  "F - test-convert-function-with-literal-arg-2/9")
@@ -881,7 +881,7 @@ test-convert-function-call-with-literal-arg:
     (check-next-stream-line-equal _test-output-stream "  89/<- %ebp 4/r32/esp"  "F - test-convert-function-call-with-literal-arg/16")
     (check-next-stream-line-equal _test-output-stream "  {"                     "F - test-convert-function-call-with-literal-arg/17")
     (check-next-stream-line-equal _test-output-stream "$do-add:0x00000002:loop:"  "F - test-convert-function-call-with-literal-arg/18")
-    (check-next-stream-line-equal _test-output-stream "    8b/copy-from *(ebp+0x00000008) 0x00000003/r32"  "F - test-convert-function-call-with-literal-arg/19")
+    (check-next-stream-line-equal _test-output-stream "    8b/-> *(ebp+0x00000008) 0x00000003/r32"  "F - test-convert-function-call-with-literal-arg/19")
     (check-next-stream-line-equal _test-output-stream "    03/add *(ebp+0x0000000c) 0x00000003/r32"  "F - test-convert-function-call-with-literal-arg/20")
     (check-next-stream-line-equal _test-output-stream "  }"                     "F - test-convert-function-call-with-literal-arg/21")
     (check-next-stream-line-equal _test-output-stream "$do-add:0x00000002:break:"  "F - test-convert-function-call-with-literal-arg/22")
@@ -1498,7 +1498,7 @@ _pending-test-local-clobbered-by-output:
     (check-next-stream-line-equal _test-output-stream "  {"                     "F - test-local-clobbered-by-output/4")
     (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:"   "F - test-local-clobbered-by-output/5")
     (check-next-stream-line-equal _test-output-stream "    b9/copy-to-ecx 4/imm32"  "F - test-local-clobbered-by-output/6")
-    (check-next-stream-line-equal _test-output-stream "    89/copy-to %ecx 0x00000001/r32"  "F - test-local-clobbered-by-output/7")
+    (check-next-stream-line-equal _test-output-stream "    89/<- %ecx 0x00000001/r32"  "F - test-local-clobbered-by-output/7")
     (check-next-stream-line-equal _test-output-stream "  }"                     "F - test-local-clobbered-by-output/8")
     (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:"  "F - test-local-clobbered-by-output/9")
     (check-next-stream-line-equal _test-output-stream "  # . epilogue"          "F - test-local-clobbered-by-output/10")
@@ -2335,8 +2335,8 @@ test-convert-length-of-array:
     (check-next-stream-line-equal _test-output-stream "  {"                     "F - test-convert-length-of-array/4")
     (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:"   "F - test-convert-length-of-array/5")
     (check-next-stream-line-equal _test-output-stream "    ff 6/subop/push %eax"  "F - test-convert-length-of-array/6")
-    (check-next-stream-line-equal _test-output-stream "    8b/copy-from *(ebp+0x00000008) 0x00000000/r32"  "F - test-convert-length-of-array/7")
-    (check-next-stream-line-equal _test-output-stream "    8b/copy-from *eax 0x00000000/r32"  "F - test-convert-length-of-array/9")
+    (check-next-stream-line-equal _test-output-stream "    8b/-> *(ebp+0x00000008) 0x00000000/r32"  "F - test-convert-length-of-array/7")
+    (check-next-stream-line-equal _test-output-stream "    8b/-> *eax 0x00000000/r32"  "F - test-convert-length-of-array/9")
     (check-next-stream-line-equal _test-output-stream "    8f 0/subop/pop %eax"  "F - test-convert-length-of-array/11")
     (check-next-stream-line-equal _test-output-stream "  }"                     "F - test-convert-length-of-array/12")
     (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:"  "F - test-convert-length-of-array/13")
@@ -2383,7 +2383,7 @@ test-convert-length-of-array-on-stack:
     (check-next-stream-line-equal _test-output-stream "    (push-n-zero-bytes 0x0000000c)"  "F - test-convert-length-of-array-on-stack/6")
     (check-next-stream-line-equal _test-output-stream "    68/push 0x0000000c/imm32"  "F - test-convert-length-of-array-on-stack/7")
     (check-next-stream-line-equal _test-output-stream "    ff 6/subop/push %eax"  "F - test-convert-length-of-array-on-stack/8")
-    (check-next-stream-line-equal _test-output-stream "    8b/copy-from *(ebp+0xfffffff0) 0x00000000/r32"  "F - test-convert-length-of-array-on-stack/9")
+    (check-next-stream-line-equal _test-output-stream "    8b/-> *(ebp+0xfffffff0) 0x00000000/r32"  "F - test-convert-length-of-array-on-stack/9")
     (check-next-stream-line-equal _test-output-stream "    8f 0/subop/pop %eax"  "F - test-convert-length-of-array-on-stack/10")
     (check-next-stream-line-equal _test-output-stream "    81 0/subop/add %esp 0x00000010/imm32"  "F - test-convert-length-of-array-on-stack/11")
     (check-next-stream-line-equal _test-output-stream "  }"                     "F - test-convert-length-of-array-on-stack/12")
@@ -2636,7 +2636,7 @@ test-convert-index-into-array-using-offset:
     (check-next-stream-line-equal _test-output-stream "    b8/copy-to-eax 0/imm32"                  "F - test-convert-index-into-array-using-offset/7")
     (check-next-stream-line-equal _test-output-stream "    ff 6/subop/push %ecx"                    "F - test-convert-index-into-array-using-offset/8")
     (check-next-stream-line-equal _test-output-stream "    b9/copy-to-ecx 3/imm32"                  "F - test-convert-index-into-array-using-offset/9")
-    (check-next-stream-line-equal _test-output-stream "    69/multiply 0x00000004/imm32 %ecx 0x00000001/r32"  "F - test-convert-index-into-array-using-offset/10")
+    (check-next-stream-line-equal _test-output-stream "    69/multiply %ecx 0x00000004/imm32 0x00000001/r32"  "F - test-convert-index-into-array-using-offset/10")
     (check-next-stream-line-equal _test-output-stream "    8d/copy-address *(eax + ecx + 4) 0x00000000/r32"  "F - test-convert-index-into-array-using-offset/11")
     (check-next-stream-line-equal _test-output-stream "    8f 0/subop/pop %ecx"                     "F - test-convert-index-into-array-using-offset/12")
     (check-next-stream-line-equal _test-output-stream "    8f 0/subop/pop %eax"                     "F - test-convert-index-into-array-using-offset/13")
@@ -2687,7 +2687,7 @@ test-convert-index-into-array-using-offset-on-stack:
     (check-next-stream-line-equal _test-output-stream "    b8/copy-to-eax 0/imm32"                  "F - test-convert-index-into-array-using-offset-on-stack/7")
     (check-next-stream-line-equal _test-output-stream "    68/push 0/imm32"                         "F - test-convert-index-into-array-using-offset-on-stack/8")
     (check-next-stream-line-equal _test-output-stream "    ff 6/subop/push %ecx"                    "F - test-convert-index-into-array-using-offset-on-stack/9")
-    (check-next-stream-line-equal _test-output-stream "    69/multiply 0x00000004/imm32 *(ebp+0xfffffff8) 0x00000001/r32"  "F - test-convert-index-into-array-using-offset-on-stack/10")
+    (check-next-stream-line-equal _test-output-stream "    69/multiply *(ebp+0xfffffff8) 0x00000004/imm32 0x00000001/r32"  "F - test-convert-index-into-array-using-offset-on-stack/10")
     (check-next-stream-line-equal _test-output-stream "    8d/copy-address *(eax + ecx + 4) 0x00000000/r32"  "F - test-convert-index-into-array-using-offset-on-stack/11")
     (check-next-stream-line-equal _test-output-stream "    8f 0/subop/pop %ecx"                     "F - test-convert-index-into-array-using-offset-on-stack/12")
     (check-next-stream-line-equal _test-output-stream "    81 0/subop/add %esp 0x00000004/imm32"    "F - test-convert-index-into-array-using-offset-on-stack/13")
@@ -2739,7 +2739,7 @@ test-convert-function-and-type-definition:
     (check-next-stream-line-equal _test-output-stream "  {"                     "F - test-convert-function-and-type-definition/4")
     (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:"   "F - test-convert-function-and-type-definition/5")
     (check-next-stream-line-equal _test-output-stream "    ff 6/subop/push %eax"  "F - test-convert-function-and-type-definition/6")
-    (check-next-stream-line-equal _test-output-stream "    8b/copy-from *(ebp+0x00000008) 0x00000000/r32"  "F - test-convert-function-and-type-definition/7")
+    (check-next-stream-line-equal _test-output-stream "    8b/-> *(ebp+0x00000008) 0x00000000/r32"  "F - test-convert-function-and-type-definition/7")
     (check-next-stream-line-equal _test-output-stream "    ff 6/subop/push %ecx"  "F - test-convert-function-and-type-definition/8")
     (check-next-stream-line-equal _test-output-stream "    8d/copy-address *(eax + 0x00000000) 0x00000001/r32"  "F - test-convert-function-and-type-definition/9")
     (check-next-stream-line-equal _test-output-stream "    8d/copy-address *(eax + 0x00000004) 0x00000001/r32"  "F - test-convert-function-and-type-definition/11")
@@ -2992,7 +2992,7 @@ test-convert-function-call-with-arg-of-user-defined-type-by-reference:
     (check-next-stream-line-equal _test-output-stream "  {"                     "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/23")
     (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:"   "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/24")
     (check-next-stream-line-equal _test-output-stream "    ff 6/subop/push %ecx"  "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/25")
-    (check-next-stream-line-equal _test-output-stream "    89/copy-to %ecx 0x00000001/r32"  "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/26")
+    (check-next-stream-line-equal _test-output-stream "    89/<- %ecx 0x00000001/r32"  "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/26")
     (check-next-stream-line-equal _test-output-stream "    ff 0/subop/increment *ecx"  "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/27")
     (check-next-stream-line-equal _test-output-stream "    8f 0/subop/pop %ecx" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/28")
     (check-next-stream-line-equal _test-output-stream "  }"                     "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/29")
@@ -3481,7 +3481,7 @@ test-function-header-with-arg:
     (clear-stream _test-input-stream)
     (write _test-input-stream "foo n: int {\n")
     # var result/ecx: function
-    2b/subtract-> *Function-size 4/r32/esp
+    2b/subtract *Function-size 4/r32/esp
     89/<- %ecx 4/r32/esp
     (zero-out %ecx *Function-size)
     # var vars/ebx: (stack (addr var) 16)
@@ -3514,7 +3514,7 @@ test-function-header-with-multiple-args:
     (clear-stream _test-input-stream)
     (write _test-input-stream "foo a: int, b: int c: int {\n")
     # result/ecx: (handle function)
-    2b/subtract-> *Function-size 4/r32/esp
+    2b/subtract *Function-size 4/r32/esp
     89/<- %ecx 4/r32/esp
     (zero-out %ecx *Function-size)
     # var vars/ebx: (stack (addr var) 16)
@@ -3566,7 +3566,7 @@ test-function-with-multiple-args-and-outputs:
     (clear-stream _test-input-stream)
     (write _test-input-stream "foo a: int, b: int, c: int -> x/ecx: int y/edx: int {\n")
     # result/ecx: (handle function)
-    2b/subtract-> *Function-size 4/r32/esp
+    2b/subtract *Function-size 4/r32/esp
     89/<- %ecx 4/r32/esp
     (zero-out %ecx *Function-size)
     # var vars/ebx: (stack (addr var) 16)
@@ -3954,7 +3954,7 @@ $next-mu-token:check0:
     # . ecx = in->read
     8b/-> *(esi+4) 1/r32/ecx
     # . if (ecx >= in->write) return out = {0, 0}
-    3b/compare 1/r32/ecx *esi
+    3b/compare<- *esi 1/r32/ecx
     c7 0/subop/copy *edi 0/imm32
     c7 0/subop/copy *(edi+4) 0/imm32
     0f 8d/jump-if->= $next-mu-token:end/disp32
@@ -3962,7 +3962,7 @@ $next-mu-token:check0:
     8d/copy-address *(esi+ecx+0xc) 0/r32/eax
     89/<- *edi 0/r32/eax
     # var curr-byte/eax: byte = in->data[in->read]
-    31/xor %eax 0/r32/eax
+    31/xor-with %eax 0/r32/eax
     8a/copy-byte *(esi+ecx+0xc) 0/r32/AL
     {
 $next-mu-token:check-for-comma:
@@ -4017,10 +4017,10 @@ $next-mu-token:regular-word-without-metadata:
       # . ecx = in->read
       8b/-> *(esi+4) 1/r32/ecx
       # . if (ecx >= in->write) break
-      3b/compare *esi 1/r32/ecx
+      3b/compare<- *esi 1/r32/ecx
       7d/jump-if->= break/disp8
       # var c/eax: byte = in->data[in->read]
-      31/xor %eax 0/r32/eax
+      31/xor-with %eax 0/r32/eax
       8a/copy-byte *(esi+ecx+0xc) 0/r32/AL
       # if (c == ' ') break
       3d/compare-eax-and 0x20/imm32/space
@@ -4813,7 +4813,7 @@ new-block-name:  # fn: (handle function) -> result/eax: (handle var)
     05/add-to-eax 0xd/imm32  # 10 + 2 for '$:'
     89/<- %ecx 0/r32/eax
     # var name/edx: (stream byte n)
-    29/subtract %esp 1/r32/ecx
+    29/subtract-from %esp 1/r32/ecx
     ff 6/subop/push %ecx
     68/push 0/imm32/read
     68/push 0/imm32/write
@@ -4834,7 +4834,7 @@ new-block-name:  # fn: (handle function) -> result/eax: (handle var)
     # . edx = name->data
     8d/copy-address *(edx+0xc) 2/r32/edx
     # . eax = name->write + name->data
-    01/add %eax 2/r32/edx
+    01/add-to %eax 2/r32/edx
     # . push {edx, eax}
     ff 6/subop/push %eax
     ff 6/subop/push %edx
@@ -4845,7 +4845,7 @@ $new-block-name:end:
     # . reclaim locals
     81 0/subop/add %ecx 0xc/imm32  # name.{read/write/len}
     81 0/subop/add %ecx 8/imm32  # slice
-    01/add %esp 1/r32/ecx
+    01/add-to %esp 1/r32/ecx
     # . restore registers
     5a/pop-to-edx
     59/pop-to-ecx
@@ -5429,7 +5429,7 @@ lookup-var-helper:  # name: (addr array byte), vars: (addr stack (handle var)) -
     # ebx = vars->top
     8b/-> *esi 3/r32/ebx
     # if (vars->top > vars->length) abort
-    3b/compare 0/r32/eax *(esi+4)
+    3b/compare<- *(esi+4) 0/r32/eax
     0f 8f/jump-if-> $lookup-var-helper:error1/disp32
     # var min/edx: (addr handle var) = vars->data
     8d/copy-address *(esi+8) 2/r32/edx
@@ -6649,7 +6649,7 @@ is-mu-array?:  # t: (handle tree type-id) -> result/eax: boolean
     8b/-> *(ebp+8) 1/r32/ecx
     8b/-> *ecx 1/r32/ecx  # Tree-left
     # if t is an atomic type, return false
-    3b/compare 1/r32/ecx *Max-type-id
+    3b/compare<- *Max-type-id 1/r32/ecx
     b8/copy-to-eax 0/imm32/false
     72/jump-if-addr< $is-mu-array?:end/disp8
     # return ecx->value == array
@@ -6875,7 +6875,7 @@ $populate-mu-type-offsets-in-inouts:loop:
       89/<- *(ebx+0xc) 2/r32/edx  # Var-offset
       # next-offset += size-of(v)
       (size-of %ebx)  # => eax
-      01/add %edx 0/r32/eax
+      01/add-to %edx 0/r32/eax
       # curr = curr->next
       8b/-> *(ecx+4) 1/r32/ecx  # List-next
       eb/jump loop/disp8
@@ -7646,7 +7646,7 @@ $clean-up-blocks:reclaim-loop:
         75/jump-if-!= break/disp8
 $clean-up-blocks:reclaim-var-on-stack:
         (size-of %eax)  # => eax
-        01/add *Curr-local-stack-offset 0/r32/eax
+        01/add-to *Curr-local-stack-offset 0/r32/eax
       }
       (pop %esi)
       e9/jump loop/disp32
@@ -7810,7 +7810,7 @@ translate-mu-length-stmt:  # out: (address buffered-file), stmt: (handle stmt)
     8b/-> *(ebp+0xc) 1/r32/ecx
     #
     (emit-indent *(ebp+8) *Curr-block-depth)
-    (write-buffered *(ebp+8) "8b/copy-from *")
+    (write-buffered *(ebp+8) "8b/-> *")
     # var base/eax: (handle var) = inouts[0]
     8b/-> *(ecx+8) 0/r32/eax  # Stmt1-inouts or Regvardef-inouts
     8b/-> *eax 0/r32/eax  # Stmt-var-value
@@ -7951,7 +7951,7 @@ $translate-mu-index-stmt-with-array-in-register:emit-int-register-index:
       # if index->type is any other atom, abort
       8b/-> *(edx+4) 0/r32/eax  # Var-type
       8b/-> *eax 0/r32/eax  # Tree-left or Atom-value
-      3b/compare 0/r32/eax *Max-type-id
+      3b/compare<- *Max-type-id 0/r32/eax
       0f 82/jump-if-addr< $translate-mu-index-stmt-with-array:error2/disp32
       # if index has type (offset ...)
       (is-simple-mu-type? %eax 7)  # offset => eax
@@ -8061,7 +8061,7 @@ $translate-mu-index-stmt-with-array-on-stack:emit-int-register-index:
       # if index->type is any other atom, abort
       8b/-> *(edx+4) 0/r32/eax  # Var-type
       8b/-> *eax 0/r32/eax  # Tree-left or Atom-value
-      3b/compare 0/r32/eax *Max-type-id
+      3b/compare<- *Max-type-id 0/r32/eax
       0f 82/jump-if-addr< $translate-mu-index-stmt-with-array:error2/disp32
       # if index has type (offset ...)
       (is-simple-mu-type? %eax 7)  # offset => eax
@@ -8090,7 +8090,7 @@ $translate-mu-index-stmt-with-array-on-stack:emit-literal-index:
       (size-of-type-id %eax)  # => eax
       f7 4/subop/multiply-into-eax %ebx  # clobbers edx
       # offset += base->offset
-      03/add-to 0/r32/eax *(ecx+0xc)  # Var-offset
+      03/add *(ecx+0xc) 0/r32/eax  # Var-offset
       # offset += 4 for array size
       05/add-to-eax 4/imm32
       # TODO: check edx for overflow
@@ -8131,22 +8131,22 @@ translate-mu-compute-index-stmt:  # out: (address buffered-file), stmt: (handle
     53/push-ebx
     #
     (emit-indent *(ebp+8) *Curr-block-depth)
-    (write-buffered *(ebp+8) "69/multiply ")
-$translate-mu-compute-index-stmt:emit-elem-size:
+    (write-buffered *(ebp+8) "69/multiply")
     # ecx = stmt
     8b/-> *(ebp+0xc) 1/r32/ecx
     # var first-inout/edx: (handle stmt-var) = stmt->inouts[0]
     8b/-> *(ecx+8) 2/r32/edx  # Stmt1-inouts
+$translate-mu-compute-index-stmt:emit-index:
+    (emit-subx-var-as-rm32 *(ebp+8) *(edx+4))  # Stmt-var-next
+    (write-buffered *(ebp+8) Space)
+$translate-mu-compute-index-stmt:emit-elem-size:
     # var base/ebx: (handle var)
     8b/-> *edx 3/r32/ebx  # Stmt-var-value
     # print size-of(element(base->type))
     (array-element-type-id %ebx)  # => eax
     (size-of-type-id %eax)  # => eax
     (print-int32-buffered *(ebp+8) %eax)
-    (write-buffered *(ebp+8) "/imm32")
-$translate-mu-compute-index-stmt:emit-index:
-    (emit-subx-var-as-rm32 *(ebp+8) *(edx+4))  # Stmt-var-next
-    (write-buffered *(ebp+8) Space)
+    (write-buffered *(ebp+8) "/imm32 ")
 $translate-mu-compute-index-stmt:emit-output:
     # outputs[0] "/r32"
     8b/-> *(ecx+0xc) 0/r32/eax  # Stmt1-outputs
@@ -8202,7 +8202,7 @@ $translate-mu-get-stmt:emit-register-input:
 $translate-mu-get-stmt:emit-stack-input:
       # "*(ebp + " inouts[0]->offset + offset ")"
       (write-buffered *(ebp+8) "*(ebp+")
-      03/add-from *(eax+0xc) 2/r32/edx  # Var-offset
+      03/add *(eax+0xc) 2/r32/edx  # Var-offset
       (print-int32-buffered *(ebp+8) %edx)
       (write-buffered *(ebp+8) ") ")
       eb/jump $translate-mu-get-stmt:emit-output/disp8
@@ -8246,26 +8246,6 @@ $array-element-type-id:end:
     5d/pop-to-ebp
     c3/return
 
-power-of-2?:  # n: int -> result/eax: boolean
-    # precondition: n is positive
-    # . prologue
-    55/push-ebp
-    89/<- %ebp 4/r32/esp
-    # var tmp/eax: int = n-1
-    8b/-> *(ebp+8) 0/r32/eax
-    48/decrement-eax
-    # var tmp2/eax: int = n & tmp
-    0b/and-> *(ebp+8) 0/r32/eax
-    # return (tmp2 == 0)
-    3d/compare-eax-and 0/imm32
-    0f 94/set-byte-if-= %al
-    81 4/subop/and %eax 0xff/imm32
-$power-of-2?:end:
-    # . epilogue
-    89/<- %esp 5/r32/ebp
-    5d/pop-to-ebp
-    c3/return
-
 num-shift-rights:  # n: int -> result/eax: int
     # precondition: n is a positive power of 2
     # . prologue
@@ -8995,11 +8975,11 @@ _Primitive-copy-to-edi:
     1/imm32/output-is-write-only
     _Primitive-copy-reg-to-reg/imm32/next
 _Primitive-copy-reg-to-reg:
-    # var1/reg <- copy var2/reg => 89/copy-to var1/rm32 var2/r32
+    # var1/reg <- copy var2/reg => 89/<- var1/rm32 var2/r32
     "copy"/imm32/name
     Single-int-var-in-some-register/imm32/inouts
     Single-int-var-in-some-register/imm32/outputs
-    "89/copy-to"/imm32/subx-name
+    "89/<-"/imm32/subx-name
     3/imm32/rm32-is-first-output
     1/imm32/r32-is-first-inout
     0/imm32/no-imm32
@@ -9007,11 +8987,11 @@ _Primitive-copy-reg-to-reg:
     1/imm32/output-is-write-only
     _Primitive-copy-reg-to-mem/imm32/next
 _Primitive-copy-reg-to-mem:
-    # copy-to var1 var2/reg => 89/copy-to var1 var2/r32
+    # copy-to var1 var2/reg => 89/<- var1 var2/r32
     "copy-to"/imm32/name
     Two-args-int-stack-int-reg/imm32/inouts
     0/imm32/outputs
-    "89/copy-to"/imm32/subx-name
+    "89/<-"/imm32/subx-name
     1/imm32/rm32-is-first-inout
     2/imm32/r32-is-second-inout
     0/imm32/no-imm32
@@ -9019,11 +8999,11 @@ _Primitive-copy-reg-to-mem:
     1/imm32/output-is-write-only
     _Primitive-copy-mem-to-reg/imm32/next
 _Primitive-copy-mem-to-reg:
-    # var1/reg <- copy var2 => 8b/copy-from var2/rm32 var1/r32
+    # var1/reg <- copy var2 => 8b/-> var2/rm32 var1/r32
     "copy"/imm32/name
     Single-int-var-in-mem/imm32/inouts
     Single-int-var-in-some-register/imm32/outputs
-    "8b/copy-from"/imm32/subx-name
+    "8b/->"/imm32/subx-name
     1/imm32/rm32-is-first-inout
     3/imm32/r32-is-first-output
     0/imm32/no-imm32
@@ -9069,7 +9049,7 @@ _Primitive-address:
     _Primitive-compare-mem-with-reg/imm32/next
 # - compare
 _Primitive-compare-mem-with-reg:
-    # compare var1 var2/reg => 39/compare-> var1/rm32 var2/r32
+    # compare var1 var2/reg => 39/compare var1/rm32 var2/r32
     "compare"/imm32/name
     Two-args-int-stack-int-reg/imm32/inouts
     0/imm32/outputs
@@ -10165,7 +10145,7 @@ emit-subx-call-operand-stack:  # out: (addr buffered-file), v: (handle var)
     # var max/eax: int = v->offset + size-of(v)
     (size-of %esi)  # => eax
     # TODO: assert size is a multiple of 4
-    01/add %eax 1/r32/ecx
+    01/add-to %eax 1/r32/ecx
     {
 $emit-subx-call-operand-stack:loop:
       # if (curr >= max) break
@@ -11081,7 +11061,7 @@ test-increment-var:
 test-add-reg-to-reg:
     #   var1/reg <- add var2/reg
     # =>
-    #   01/add %var1 var2
+    #   01/add-to %var1 var2
     #
     # . prologue
     55/push-ebp
@@ -11144,7 +11124,7 @@ test-add-reg-to-reg:
 test-add-reg-to-mem:
     #   add-to var1 var2/reg
     # =>
-    #   01/add *(ebp+__) var2
+    #   01/add-to *(ebp+__) var2
     #
     # . prologue
     55/push-ebp
@@ -11533,7 +11513,7 @@ test-compare-mem-with-reg:
 test-compare-reg-with-mem:
     #   compare var1/eax, var2
     # =>
-    #   3b/compare *(ebp+___) 0/r32/eax
+    #   3b/compare<- *(ebp+___) 0/r32/eax
     #
     # . prologue
     55/push-ebp
diff --git a/mu_instructions b/mu_instructions
index 430a4651..b5d0e450 100644
--- a/mu_instructions
+++ b/mu_instructions
@@ -26,14 +26,14 @@ There are no checks for types yet, because Mu programs only have `int` types so
 Example 1 (use the widest screen you can for this page):
    -- instruction form --   |         -------------------------- data structure ----------------------------
                             |<------------- pattern matching ---------->|<--- code generation ------------------->
-  var/reg <- add var2/reg   {.name="add", .inouts=[reg], .outputs=[reg], .subx-name="01/add<-", .rm32=outputs[0], .r32=inouts[0]}
+  var/reg <- add var2/reg   {.name="add", .inouts=[reg], .outputs=[reg], .subx-name="01/add-to", .rm32=outputs[0], .r32=inouts[0]}
 
 Read this as:
   if an instruction's name is "add"
     and it has one inout that's in a register
     and it has one output that's in a register,
   then emit the following on a single line
-    "01/add<-" (the opcode or subx-name)
+    "01/add-to" (the opcode or subx-name)
     "%{reg}", interpolating the output's register
     "{reg}/r32", interpolating the inout's register code.
 
@@ -74,46 +74,46 @@ var/edi <- decrement        {.name="decrement",                       .outputs=[
 decrement var               {.name="decrement",       .inouts=[var],                    .subx-name="ff 1/subop/decrement",  .rm32="*(ebp+" inouts[0].stack-offset ")"}
 decrement *var/reg          {.name="decrement",       .inouts=[reg],                    .subx-name="ff 1/subop/decrement",  .rm32="*" inouts[0]}
 
-var1/reg1 <- add var2/reg2  {.name="add",             .inouts=[reg2], .outputs=[reg1],  .subx-name="01/add<-",              .rm32=outputs[0],                           .r32=inouts[0]}
-var/reg <- add var2         {.name="add",             .inouts=[var2], .outputs=[reg],   .subx-name="03/add->",              .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=outputs[0]}
-var/reg <- add *var2/reg2   {.name="add",             .inouts=[reg2], .outputs=[reg],   .subx-name="03/add->",              .rm32="*" inouts[0],                        .r32=outputs[0]}
-add-to var1, var2/reg       {.name="add-to",          .inouts=[var1, var2],             .subx-name="01/add<-",              .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=inouts[1]}
+var1/reg1 <- add var2/reg2  {.name="add",             .inouts=[reg2], .outputs=[reg1],  .subx-name="01/add-to",             .rm32=outputs[0],                           .r32=inouts[0]}
+var/reg <- add var2         {.name="add",             .inouts=[var2], .outputs=[reg],   .subx-name="03/add",                .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=outputs[0]}
+var/reg <- add *var2/reg2   {.name="add",             .inouts=[reg2], .outputs=[reg],   .subx-name="03/add",                .rm32="*" inouts[0],                        .r32=outputs[0]}
+add-to var1, var2/reg       {.name="add-to",          .inouts=[var1, var2],             .subx-name="01/add-to",             .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=inouts[1]}
 var/eax <- add n            {.name="add",             .inouts=[n],    .outputs=[eax],   .subx-name="05/add-to-eax",                                                                         .imm32=inouts[0]}
 var/reg <- add n            {.name="add",             .inouts=[n],    .outputs=[reg],   .subx-name="81 0/subop/add",        .rm32=outputs[0],                                               .imm32=inouts[0]}
 add-to var, n               {.name="add-to",          .inouts=[var, n],                 .subx-name="81 0/subop/add",        .rm32="*(ebp+" inouts[0].stack-offset ")",                      .imm32=inouts[1]}
 add-to *var/reg, n          {.name="add-to",          .inouts=[reg, n],                 .subx-name="81 0/subop/add",        .rm32="*" inouts[0],                                            .imm32=inouts[1]}
 
-var1/reg1 <- sub var2/reg2  {.name="sub",             .inouts=[reg2], .outputs=[reg1],  .subx-name="29/sub<-",              .rm32=outputs[0],                           .r32=inouts[0]}
-var/reg <- sub var2         {.name="sub",             .inouts=[var2], .outputs=[reg],   .subx-name="2b/sub->",              .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=outputs[0]}
-var/reg <- sub *var2/reg2   {.name="sub",             .inouts=[reg2], .outputs=[reg],   .subx-name="2b/sub->",              .rm32="*" inouts[0],                        .r32=outputs[0]}
-sub-from var1, var2/reg     {.name="sub-from",        .inouts=[var1, var2],             .subx-name="29/sub<-",              .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=inouts[1]}
-var/eax <- sub n            {.name="sub",             .inouts=[n],    .outputs=[eax],   .subx-name="2d/sub-from-eax",                                                                       .imm32=inouts[0]}
+var1/reg1 <- sub var2/reg2  {.name="sub",             .inouts=[reg2], .outputs=[reg1],  .subx-name="29/subtract-from",      .rm32=outputs[0],                           .r32=inouts[0]}
+var/reg <- sub var2         {.name="sub",             .inouts=[var2], .outputs=[reg],   .subx-name="2b/subtract",           .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=outputs[0]}
+var/reg <- sub *var2/reg2   {.name="sub",             .inouts=[reg2], .outputs=[reg],   .subx-name="2b/subtract",           .rm32="*" inouts[0],                        .r32=outputs[0]}
+sub-from var1, var2/reg     {.name="sub-from",        .inouts=[var1, var2],             .subx-name="29/subtract-from",      .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=inouts[1]}
+var/eax <- sub n            {.name="sub",             .inouts=[n],    .outputs=[eax],   .subx-name="2d/subtract-from-eax",                                                                  .imm32=inouts[0]}
 var/reg <- sub n            {.name="sub",             .inouts=[n],    .outputs=[reg],   .subx-name="81 5/subop/subtract",   .rm32=outputs[0],                                               .imm32=inouts[0]}
 sub-from var, n             {.name="sub-from",        .inouts=[var, n],                 .subx-name="81 5/subop/subtract",   .rm32="*(ebp+" inouts[0].stack-offset ")",                      .imm32=inouts[1]}
 sub-from *var/reg, n        {.name="sub-from",        .inouts=[reg, n],                 .subx-name="81 5/subop/subtract",   .rm32="*" inouts[0],                                            .imm32=inouts[1]}
 
-var1/reg1 <- and var2/reg2  {.name="and",             .inouts=[reg2], .outputs=[reg1],  .subx-name="21/and<-",              .rm32=outputs[0],                           .r32=inouts[0]}
-var/reg <- and var2         {.name="and",             .inouts=[var2], .outputs=[reg],   .subx-name="23/and->",              .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=outputs[0]}
-var/reg <- and *var2/reg2   {.name="and",             .inouts=[reg2], .outputs=[reg],   .subx-name="23/and->",              .rm32="*" inouts[0],                        .r32=outputs[0]}
-and-with var1, var2/reg     {.name="and-with",        .inouts=[var1, reg],              .subx-name="21/and<-",              .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=inouts[1]}
+var1/reg1 <- and var2/reg2  {.name="and",             .inouts=[reg2], .outputs=[reg1],  .subx-name="21/and-with",           .rm32=outputs[0],                           .r32=inouts[0]}
+var/reg <- and var2         {.name="and",             .inouts=[var2], .outputs=[reg],   .subx-name="23/and",                .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=outputs[0]}
+var/reg <- and *var2/reg2   {.name="and",             .inouts=[reg2], .outputs=[reg],   .subx-name="23/and",                .rm32="*" inouts[0],                        .r32=outputs[0]}
+and-with var1, var2/reg     {.name="and-with",        .inouts=[var1, reg],              .subx-name="21/and-with",           .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=inouts[1]}
 var/eax <- and n            {.name="and",             .inouts=[n],    .outputs=[eax],   .subx-name="25/and-with-eax",                                                                       .imm32=inouts[0]}
 var/reg <- and n            {.name="and",             .inouts=[n],    .outputs=[reg],   .subx-name="81 4/subop/and",        .rm32=outputs[0],                                               .imm32=inouts[0]}
 and-with var, n             {.name="and-with",        .inouts=[var, n],                 .subx-name="81 4/subop/and",        .rm32="*(ebp+" inouts[0].stack-offset ")",                      .imm32=inouts[1]}
 and-with *var/reg, n        {.name="and-with",        .inouts=[reg, n],                 .subx-name="81 4/subop/and",        .rm32="*" inouts[0],                                            .imm32=inouts[1]}
 
-var1/reg1 <- or var2/reg2   {.name="or",              .inouts=[reg2], .outputs=[reg1],  .subx-name="09/or<-",               .rm32=outputs[0],                           .r32=inouts[0]}
-var/reg <- or var2          {.name="or",              .inouts=[var2], .outputs=[reg],   .subx-name="0b/or->",               .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=outputs[0]}
-var/reg <- or *var2/reg2    {.name="or",              .inouts=[reg2], .outputs=[reg],   .subx-name="0b/or->",               .rm32="*" inouts[0],                        .r32=outputs[0]}
-or-with var1, var2/reg      {.name="or-with",         .inouts=[var1, reg],              .subx-name="09/or<-",               .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=inouts[1]}
+var1/reg1 <- or var2/reg2   {.name="or",              .inouts=[reg2], .outputs=[reg1],  .subx-name="09/or-with",            .rm32=outputs[0],                           .r32=inouts[0]}
+var/reg <- or var2          {.name="or",              .inouts=[var2], .outputs=[reg],   .subx-name="0b/or",                 .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=outputs[0]}
+var/reg <- or *var2/reg2    {.name="or",              .inouts=[reg2], .outputs=[reg],   .subx-name="0b/or",                 .rm32="*" inouts[0],                        .r32=outputs[0]}
+or-with var1, var2/reg      {.name="or-with",         .inouts=[var1, reg],              .subx-name="09/or-with",            .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=inouts[1]}
 var/eax <- or n             {.name="or",              .inouts=[n],    .outputs=[eax],   .subx-name="0d/or-with-eax",                                                                        .imm32=inouts[0]}
 var/reg <- or n             {.name="or",              .inouts=[n],    .outputs=[reg],   .subx-name="81 1/subop/or",         .rm32=outputs[0],                                               .imm32=inouts[0]}
 or-with var, n              {.name="or-with",         .inouts=[var, n],                 .subx-name="81 1/subop/or",         .rm32="*(ebp+" inouts[0].stack-offset ")",                      .imm32=inouts[1]}
 or-with *var/reg, n         {.name="or-with",         .inouts=[reg, n],                 .subx-name="81 1/subop/or",         .rm32="*" inouts[0],                                            .imm32=inouts[1]}
 
-var1/reg1 <- xor var2/reg2  {.name="xor",             .inouts=[reg2], .outputs=[reg1],  .subx-name="31/xor<-",              .rm32=outputs[0],                           .r32=inouts[0]}
-var/reg <- xor var2         {.name="xor",             .inouts=[var2], .outputs=[reg],   .subx-name="33/xor->",              .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=outputs[0]}
-var/reg <- xor *var2/reg2   {.name="xor",             .inouts=[reg2], .outputs=[reg],   .subx-name="33/xor->",              .rm32="*" inouts[0],                        .r32=outputs[0]}
-xor-with var1, var2/reg     {.name="xor-with",        .inouts=[var1, reg],              .subx-name="31/xor<-",              .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=inouts[1]}
+var1/reg1 <- xor var2/reg2  {.name="xor",             .inouts=[reg2], .outputs=[reg1],  .subx-name="31/xor-with",           .rm32=outputs[0],                           .r32=inouts[0]}
+var/reg <- xor var2         {.name="xor",             .inouts=[var2], .outputs=[reg],   .subx-name="33/xor",                .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=outputs[0]}
+var/reg <- xor *var2/reg2   {.name="xor",             .inouts=[reg2], .outputs=[reg],   .subx-name="33/xor",                .rm32="*" inouts[0],                        .r32=outputs[0]}
+xor-with var1, var2/reg     {.name="xor-with",        .inouts=[var1, reg],              .subx-name="31/xor-with",           .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=inouts[1]}
 var/eax <- xor n            {.name="xor",             .inouts=[n],    .outputs=[eax],   .subx-name="35/xor-with-eax",                                                                       .imm32=inouts[0]}
 var/reg <- xor n            {.name="xor",             .inouts=[n],    .outputs=[reg],   .subx-name="81 6/subop/xor",        .rm32=outputs[0],                                               .imm32=inouts[0]}
 xor-with var, n             {.name="xor-with",        .inouts=[var, n],                 .subx-name="81 6/subop/xor",        .rm32="*(ebp+" inouts[0].stack-offset ")",                      .imm32=inouts[1]}
@@ -125,16 +125,16 @@ var/edx <- copy n           {.name="copy",            .inouts=[n],    .outputs=[
 var/ebx <- copy n           {.name="copy",            .inouts=[n],    .outputs=[ebx],   .subx-name="bb/copy-to-ebx",                                                                        .imm32=inouts[0]}
 var/esi <- copy n           {.name="copy",            .inouts=[n],    .outputs=[esi],   .subx-name="be/copy-to-esi",                                                                        .imm32=inouts[0]}
 var/edi <- copy n           {.name="copy",            .inouts=[n],    .outputs=[edi],   .subx-name="bf/copy-to-edi",                                                                        .imm32=inouts[0]}
-var1/reg1 <- copy var2/reg2 {.name="copy",            .inouts=[reg2], .outputs=[reg1],  .subx-name="89/copy-to",            .rm32=outputs[0],                           .r32=inouts[0]}
-copy-to var1, var2/reg      {.name="copy-to",         .inouts=[var1, var2],             .subx-name="01/add<-",              .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=inouts[1]}
-var/reg <- copy var2        {.name="copy",            .inouts=[var2], .outputs=[reg],   .subx-name="8b/copy-from",          .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=outputs[0]}
-var1/reg <- copy *var2/reg2 {.name="copy",            .inouts=[reg2], .outputs=[reg],   .subx-name="8b/copy-from",          .rm32="*" inouts[0],                        .r32=outputs[0]}
+var1/reg1 <- copy var2/reg2 {.name="copy",            .inouts=[reg2], .outputs=[reg1],  .subx-name="89/<-",                 .rm32=outputs[0],                           .r32=inouts[0]}
+copy-to var1, var2/reg      {.name="copy-to",         .inouts=[var1, var2],             .subx-name="89/<-",                 .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=inouts[1]}
+var/reg <- copy var2        {.name="copy",            .inouts=[var2], .outputs=[reg],   .subx-name="8b/->",                 .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=outputs[0]}
+var1/reg <- copy *var2/reg2 {.name="copy",            .inouts=[reg2], .outputs=[reg],   .subx-name="8b/->",                 .rm32="*" inouts[0],                        .r32=outputs[0]}
 var/reg <- copy n           {.name="copy",            .inouts=[n],    .outputs=[reg],   .subx-name="c7 0/subop/copy",       .rm32=outputs[0],                                               .imm32=inouts[0]}
 copy-to var, n              {.name="copy-to",         .inouts=[var, n],                 .subx-name="c7 0/subop/copy",       .rm32="*(ebp+" inouts[0].stack-offset ")",                      .imm32=inouts[1]}
 copy-to *var/reg, n         {.name="copy-to",         .inouts=[reg, n],                 .subx-name="c7 0/subop/copy",       .rm32="*" inouts[0],                                            .imm32=inouts[1]}
 
-compare var1, var2/reg      {.name="compare",         .inouts=[var1, reg],              .subx-name="39/compare->",          .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=inouts[1]}
-compare *var1/reg1, var/reg {.name="compare",         .inouts=[reg1, reg],              .subx-name="39/compare->",          .rm32="*" inouts[0],                        .r32=inouts[1]}
+compare var1, var2/reg      {.name="compare",         .inouts=[var1, reg],              .subx-name="39/compare",            .rm32="*(ebp+" inouts[0].stack-offset ")",  .r32=inouts[1]}
+compare *var1/reg1, var/reg {.name="compare",         .inouts=[reg1, reg],              .subx-name="39/compare",            .rm32="*" inouts[0],                        .r32=inouts[1]}
 compare var1/reg, var2      {.name="compare",         .inouts=[reg, var2],              .subx-name="3b/compare<-",          .rm32="*(ebp+" inouts[1].stack-offset ")",  .r32=inouts[0]}
 compare var/reg, *var2/reg2 {.name="compare",         .inouts=[reg, reg2],              .subx-name="3b/compare<-",          .rm32="*" inouts[1],                        .r32=inouts[0]}
 compare var/eax, n          {.name="compare",         .inouts=[eax, n],                 .subx-name="3d/compare-eax-with",                                                                   .imm32=inouts[1]}