6793

8 files changed, 83 insertions, 516 deletions

diff --git a/406try-divide.mu b/406try-divide.mu
new file mode 100644
index 00000000..9c7a0229
--- /dev/null
+++ b/406try-divide.mu
@@ -0,0 +1,83 @@
+# slow, iterative divide instruction
+# preconditions: _nr >= 0, _dr > 0
+fn try-divide _nr: int, _dr: int -> result/eax: int {
+  # x = next power-of-2 multiple of _dr after _nr
+  var x/ecx: int <- copy 1
+  {
+#?     print-int32-hex 0, x
+#?     print-string 0, "\n"
+    var tmp/edx: int <- copy _dr
+    tmp <- multiply x
+    compare tmp, _nr
+    break-if->
+    x <- shift-left 1
+    loop
+  }
+#?   print-string 0, "--\n"
+  # min, max = x/2, x
+  var max/ecx: int <- copy x
+  var min/edx: int <- copy max
+  min <- shift-right 1
+  # narrow down result between min and max
+  var i/eax: int <- copy min
+  {
+#?     print-int32-hex 0, i
+#?     print-string 0, "\n"
+    var foo/ebx: int <- copy _dr
+    foo <- multiply i
+    compare foo, _nr
+    break-if->
+    i <- increment
+    loop
+  }
+  result <- copy i
+  result <- decrement
+#?   print-string 0, "=> "
+#?   print-int32-hex 0, result
+#?   print-string 0, "\n"
+}
+
+fn test-try-divide-1 {
+  var result/eax: int <- try-divide 0, 2
+  check-ints-equal result, 0, "F - try-divide-1\n"
+}
+
+fn test-try-divide-2 {
+  var result/eax: int <- try-divide 1, 2
+  check-ints-equal result, 0, "F - try-divide-2\n"
+}
+
+fn test-try-divide-3 {
+  var result/eax: int <- try-divide 2, 2
+  check-ints-equal result, 1, "F - try-divide-3\n"
+}
+
+fn test-try-divide-4 {
+  var result/eax: int <- try-divide 4, 2
+  check-ints-equal result, 2, "F - try-divide-4\n"
+}
+
+fn test-try-divide-5 {
+  var result/eax: int <- try-divide 6, 2
+  check-ints-equal result, 3, "F - try-divide-5\n"
+}
+
+fn test-try-divide-6 {
+  var result/eax: int <- try-divide 9, 3
+  check-ints-equal result, 3, "F - try-divide-6\n"
+}
+
+fn test-try-divide-7 {
+  var result/eax: int <- try-divide 0xc, 4
+  check-ints-equal result, 3, "F - try-divide-7\n"
+}
+
+fn test-try-divide-8 {
+  var result/eax: int <- try-divide 0x1b, 3  # 27/3
+  check-ints-equal result, 9, "F - try-divide-8\n"
+}
+
+fn test-try-divide-9 {
+  var result/eax: int <- try-divide 0x1c, 3  # 28/3
+  check-ints-equal result, 9, "F - try-divide-9\n"
+}
diff --git a/prototypes/tile/10.mu b/prototypes/tile/10.mu
index 32790364..73ce73ff 100644
--- a/prototypes/tile/10.mu
+++ b/prototypes/tile/10.mu
@@ -339,87 +339,3 @@ fn draw-vertical-line row1: int, row2: int, col: int {
     loop
   }
 }
-
-# slow, iterative divide instruction
-# preconditions: _nr >= 0, _dr > 0
-fn try-divide _nr: int, _dr: int -> result/eax: int {
-  # x = next power-of-2 multiple of _dr after _nr
-  var x/ecx: int <- copy 1
-  {
-#?     print-int32-hex 0, x
-#?     print-string 0, "\n"
-    var tmp/edx: int <- copy _dr
-    tmp <- multiply x
-    compare tmp, _nr
-    break-if->
-    x <- shift-left 1
-    loop
-  }
-#?   print-string 0, "--\n"
-  # min, max = x/2, x
-  var max/ecx: int <- copy x
-  var min/edx: int <- copy max
-  min <- shift-right 1
-  # narrow down result between min and max
-  var i/eax: int <- copy min
-  {
-#?     print-int32-hex 0, i
-#?     print-string 0, "\n"
-    var foo/ebx: int <- copy _dr
-    foo <- multiply i
-    compare foo, _nr
-    break-if->
-    i <- increment
-    loop
-  }
-  result <- copy i
-  result <- decrement
-#?   print-string 0, "=> "
-#?   print-int32-hex 0, result
-#?   print-string 0, "\n"
-}
-
-fn test-try-divide-1 {
-  var result/eax: int <- try-divide 0, 2
-  check-ints-equal result, 0, "F - try-divide-1\n"
-}
-
-fn test-try-divide-2 {
-  var result/eax: int <- try-divide 1, 2
-  check-ints-equal result, 0, "F - try-divide-2\n"
-}
-
-fn test-try-divide-3 {
-  var result/eax: int <- try-divide 2, 2
-  check-ints-equal result, 1, "F - try-divide-3\n"
-}
-
-fn test-try-divide-4 {
-  var result/eax: int <- try-divide 4, 2
-  check-ints-equal result, 2, "F - try-divide-4\n"
-}
-
-fn test-try-divide-5 {
-  var result/eax: int <- try-divide 6, 2
-  check-ints-equal result, 3, "F - try-divide-5\n"
-}
-
-fn test-try-divide-6 {
-  var result/eax: int <- try-divide 9, 3
-  check-ints-equal result, 3, "F - try-divide-6\n"
-}
-
-fn test-try-divide-7 {
-  var result/eax: int <- try-divide 0xc, 4
-  check-ints-equal result, 3, "F - try-divide-7\n"
-}
-
-fn test-try-divide-8 {
-  var result/eax: int <- try-divide 0x1b, 3  # 27/3
-  check-ints-equal result, 9, "F - try-divide-8\n"
-}
-
-fn test-try-divide-9 {
-  var result/eax: int <- try-divide 0x1c, 3  # 28/3
-  check-ints-equal result, 9, "F - try-divide-9\n"
-}
diff --git a/prototypes/tile/11.mu b/prototypes/tile/11.mu
index 932e358d..8d3593e3 100644
--- a/prototypes/tile/11.mu
+++ b/prototypes/tile/11.mu
@@ -351,87 +351,3 @@ fn draw-vertical-line row1: int, row2: int, col: int {
     loop
   }
 }
-
-# slow, iterative divide instruction
-# preconditions: _nr >= 0, _dr > 0
-fn try-divide _nr: int, _dr: int -> result/eax: int {
-  # x = next power-of-2 multiple of _dr after _nr
-  var x/ecx: int <- copy 1
-  {
-#?     print-int32-hex 0, x
-#?     print-string 0, "\n"
-    var tmp/edx: int <- copy _dr
-    tmp <- multiply x
-    compare tmp, _nr
-    break-if->
-    x <- shift-left 1
-    loop
-  }
-#?   print-string 0, "--\n"
-  # min, max = x/2, x
-  var max/ecx: int <- copy x
-  var min/edx: int <- copy max
-  min <- shift-right 1
-  # narrow down result between min and max
-  var i/eax: int <- copy min
-  {
-#?     print-int32-hex 0, i
-#?     print-string 0, "\n"
-    var foo/ebx: int <- copy _dr
-    foo <- multiply i
-    compare foo, _nr
-    break-if->
-    i <- increment
-    loop
-  }
-  result <- copy i
-  result <- decrement
-#?   print-string 0, "=> "
-#?   print-int32-hex 0, result
-#?   print-string 0, "\n"
-}
-
-fn test-try-divide-1 {
-  var result/eax: int <- try-divide 0, 2
-  check-ints-equal result, 0, "F - try-divide-1\n"
-}
-
-fn test-try-divide-2 {
-  var result/eax: int <- try-divide 1, 2
-  check-ints-equal result, 0, "F - try-divide-2\n"
-}
-
-fn test-try-divide-3 {
-  var result/eax: int <- try-divide 2, 2
-  check-ints-equal result, 1, "F - try-divide-3\n"
-}
-
-fn test-try-divide-4 {
-  var result/eax: int <- try-divide 4, 2
-  check-ints-equal result, 2, "F - try-divide-4\n"
-}
-
-fn test-try-divide-5 {
-  var result/eax: int <- try-divide 6, 2
-  check-ints-equal result, 3, "F - try-divide-5\n"
-}
-
-fn test-try-divide-6 {
-  var result/eax: int <- try-divide 9, 3
-  check-ints-equal result, 3, "F - try-divide-6\n"
-}
-
-fn test-try-divide-7 {
-  var result/eax: int <- try-divide 0xc, 4
-  check-ints-equal result, 3, "F - try-divide-7\n"
-}
-
-fn test-try-divide-8 {
-  var result/eax: int <- try-divide 0x1b, 3  # 27/3
-  check-ints-equal result, 9, "F - try-divide-8\n"
-}
-
-fn test-try-divide-9 {
-  var result/eax: int <- try-divide 0x1c, 3  # 28/3
-  check-ints-equal result, 9, "F - try-divide-9\n"
-}
diff --git a/prototypes/tile/5.mu b/prototypes/tile/5.mu
index 941f132e..a49c4922 100644
--- a/prototypes/tile/5.mu
+++ b/prototypes/tile/5.mu
@@ -113,18 +113,6 @@ fn tree-depth node-on-stack: (addr cell) -> result/eax: int {
   result <- increment
 }
 
-# slow, iterative divide instruction
-fn try-divide _nr: int, _dr: int -> result/eax: int {
-  result <- copy _nr
-  result <- shift-right 2
-#?   var nr/ecx: int <- copy _nr
-#?   var tmp/ecx: int <- copy 2
-#?   # find nearest power of 2
-#?   {
-#?     k
-#?   }
-}
-
 fn draw-box row1: int, col1: int, row2: int, col2: int {
   draw-horizontal-line row1, col1, col2
   draw-vertical-line row1, row2, col1
diff --git a/prototypes/tile/6.mu b/prototypes/tile/6.mu
index bf601e00..ee7ef8c0 100644
--- a/prototypes/tile/6.mu
+++ b/prototypes/tile/6.mu
@@ -182,87 +182,3 @@ fn draw-vertical-line row1: int, row2: int, col: int {
     loop
   }
 }
-
-# slow, iterative divide instruction
-# preconditions: _nr >= 0, _dr > 0
-fn try-divide _nr: int, _dr: int -> result/eax: int {
-  # x = next power-of-2 multiple of _dr after _nr
-  var x/ecx: int <- copy 1
-  {
-#?     print-int32-hex 0, x
-#?     print-string 0, "\n"
-    var tmp/edx: int <- copy _dr
-    tmp <- multiply x
-    compare tmp, _nr
-    break-if->
-    x <- shift-left 1
-    loop
-  }
-#?   print-string 0, "--\n"
-  # min, max = x/2, x
-  var max/ecx: int <- copy x
-  var min/edx: int <- copy max
-  min <- shift-right 1
-  # narrow down result between min and max
-  var i/eax: int <- copy min
-  {
-#?     print-int32-hex 0, i
-#?     print-string 0, "\n"
-    var foo/ebx: int <- copy _dr
-    foo <- multiply i
-    compare foo, _nr
-    break-if->
-    i <- increment
-    loop
-  }
-  result <- copy i
-  result <- decrement
-#?   print-string 0, "=> "
-#?   print-int32-hex 0, result
-#?   print-string 0, "\n"
-}
-
-fn test-try-divide-1 {
-  var result/eax: int <- try-divide 0, 2
-  check-ints-equal result, 0, "F - try-divide-1\n"
-}
-
-fn test-try-divide-2 {
-  var result/eax: int <- try-divide 1, 2
-  check-ints-equal result, 0, "F - try-divide-2\n"
-}
-
-fn test-try-divide-3 {
-  var result/eax: int <- try-divide 2, 2
-  check-ints-equal result, 1, "F - try-divide-3\n"
-}
-
-fn test-try-divide-4 {
-  var result/eax: int <- try-divide 4, 2
-  check-ints-equal result, 2, "F - try-divide-4\n"
-}
-
-fn test-try-divide-5 {
-  var result/eax: int <- try-divide 6, 2
-  check-ints-equal result, 3, "F - try-divide-5\n"
-}
-
-fn test-try-divide-6 {
-  var result/eax: int <- try-divide 9, 3
-  check-ints-equal result, 3, "F - try-divide-6\n"
-}
-
-fn test-try-divide-7 {
-  var result/eax: int <- try-divide 0xc, 4
-  check-ints-equal result, 3, "F - try-divide-7\n"
-}
-
-fn test-try-divide-8 {
-  var result/eax: int <- try-divide 0x1b, 3  # 27/3
-  check-ints-equal result, 9, "F - try-divide-8\n"
-}
-
-fn test-try-divide-9 {
-  var result/eax: int <- try-divide 0x1c, 3  # 28/3
-  check-ints-equal result, 9, "F - try-divide-9\n"
-}
diff --git a/prototypes/tile/7.mu b/prototypes/tile/7.mu
index 129cb616..92b92b34 100644
--- a/prototypes/tile/7.mu
+++ b/prototypes/tile/7.mu
@@ -196,87 +196,3 @@ fn draw-vertical-line row1: int, row2: int, col: int {
     loop
   }
 }
-
-# slow, iterative divide instruction
-# preconditions: _nr >= 0, _dr > 0
-fn try-divide _nr: int, _dr: int -> result/eax: int {
-  # x = next power-of-2 multiple of _dr after _nr
-  var x/ecx: int <- copy 1
-  {
-#?     print-int32-hex 0, x
-#?     print-string 0, "\n"
-    var tmp/edx: int <- copy _dr
-    tmp <- multiply x
-    compare tmp, _nr
-    break-if->
-    x <- shift-left 1
-    loop
-  }
-#?   print-string 0, "--\n"
-  # min, max = x/2, x
-  var max/ecx: int <- copy x
-  var min/edx: int <- copy max
-  min <- shift-right 1
-  # narrow down result between min and max
-  var i/eax: int <- copy min
-  {
-#?     print-int32-hex 0, i
-#?     print-string 0, "\n"
-    var foo/ebx: int <- copy _dr
-    foo <- multiply i
-    compare foo, _nr
-    break-if->
-    i <- increment
-    loop
-  }
-  result <- copy i
-  result <- decrement
-#?   print-string 0, "=> "
-#?   print-int32-hex 0, result
-#?   print-string 0, "\n"
-}
-
-fn test-try-divide-1 {
-  var result/eax: int <- try-divide 0, 2
-  check-ints-equal result, 0, "F - try-divide-1\n"
-}
-
-fn test-try-divide-2 {
-  var result/eax: int <- try-divide 1, 2
-  check-ints-equal result, 0, "F - try-divide-2\n"
-}
-
-fn test-try-divide-3 {
-  var result/eax: int <- try-divide 2, 2
-  check-ints-equal result, 1, "F - try-divide-3\n"
-}
-
-fn test-try-divide-4 {
-  var result/eax: int <- try-divide 4, 2
-  check-ints-equal result, 2, "F - try-divide-4\n"
-}
-
-fn test-try-divide-5 {
-  var result/eax: int <- try-divide 6, 2
-  check-ints-equal result, 3, "F - try-divide-5\n"
-}
-
-fn test-try-divide-6 {
-  var result/eax: int <- try-divide 9, 3
-  check-ints-equal result, 3, "F - try-divide-6\n"
-}
-
-fn test-try-divide-7 {
-  var result/eax: int <- try-divide 0xc, 4
-  check-ints-equal result, 3, "F - try-divide-7\n"
-}
-
-fn test-try-divide-8 {
-  var result/eax: int <- try-divide 0x1b, 3  # 27/3
-  check-ints-equal result, 9, "F - try-divide-8\n"
-}
-
-fn test-try-divide-9 {
-  var result/eax: int <- try-divide 0x1c, 3  # 28/3
-  check-ints-equal result, 9, "F - try-divide-9\n"
-}
diff --git a/prototypes/tile/8.mu b/prototypes/tile/8.mu
index b8f450c6..c64a1577 100644
--- a/prototypes/tile/8.mu
+++ b/prototypes/tile/8.mu
@@ -226,87 +226,3 @@ fn draw-vertical-line row1: int, row2: int, col: int {
     loop
   }
 }
-
-# slow, iterative divide instruction
-# preconditions: _nr >= 0, _dr > 0
-fn try-divide _nr: int, _dr: int -> result/eax: int {
-  # x = next power-of-2 multiple of _dr after _nr
-  var x/ecx: int <- copy 1
-  {
-#?     print-int32-hex 0, x
-#?     print-string 0, "\n"
-    var tmp/edx: int <- copy _dr
-    tmp <- multiply x
-    compare tmp, _nr
-    break-if->
-    x <- shift-left 1
-    loop
-  }
-#?   print-string 0, "--\n"
-  # min, max = x/2, x
-  var max/ecx: int <- copy x
-  var min/edx: int <- copy max
-  min <- shift-right 1
-  # narrow down result between min and max
-  var i/eax: int <- copy min
-  {
-#?     print-int32-hex 0, i
-#?     print-string 0, "\n"
-    var foo/ebx: int <- copy _dr
-    foo <- multiply i
-    compare foo, _nr
-    break-if->
-    i <- increment
-    loop
-  }
-  result <- copy i
-  result <- decrement
-#?   print-string 0, "=> "
-#?   print-int32-hex 0, result
-#?   print-string 0, "\n"
-}
-
-fn test-try-divide-1 {
-  var result/eax: int <- try-divide 0, 2
-  check-ints-equal result, 0, "F - try-divide-1\n"
-}
-
-fn test-try-divide-2 {
-  var result/eax: int <- try-divide 1, 2
-  check-ints-equal result, 0, "F - try-divide-2\n"
-}
-
-fn test-try-divide-3 {
-  var result/eax: int <- try-divide 2, 2
-  check-ints-equal result, 1, "F - try-divide-3\n"
-}
-
-fn test-try-divide-4 {
-  var result/eax: int <- try-divide 4, 2
-  check-ints-equal result, 2, "F - try-divide-4\n"
-}
-
-fn test-try-divide-5 {
-  var result/eax: int <- try-divide 6, 2
-  check-ints-equal result, 3, "F - try-divide-5\n"
-}
-
-fn test-try-divide-6 {
-  var result/eax: int <- try-divide 9, 3
-  check-ints-equal result, 3, "F - try-divide-6\n"
-}
-
-fn test-try-divide-7 {
-  var result/eax: int <- try-divide 0xc, 4
-  check-ints-equal result, 3, "F - try-divide-7\n"
-}
-
-fn test-try-divide-8 {
-  var result/eax: int <- try-divide 0x1b, 3  # 27/3
-  check-ints-equal result, 9, "F - try-divide-8\n"
-}
-
-fn test-try-divide-9 {
-  var result/eax: int <- try-divide 0x1c, 3  # 28/3
-  check-ints-equal result, 9, "F - try-divide-9\n"
-}
diff --git a/prototypes/tile/9.mu b/prototypes/tile/9.mu
index e7289fc2..69360b2e 100644
--- a/prototypes/tile/9.mu
+++ b/prototypes/tile/9.mu
@@ -304,87 +304,3 @@ fn draw-vertical-line row1: int, row2: int, col: int {
     loop
   }
 }
-
-# slow, iterative divide instruction
-# preconditions: _nr >= 0, _dr > 0
-fn try-divide _nr: int, _dr: int -> result/eax: int {
-  # x = next power-of-2 multiple of _dr after _nr
-  var x/ecx: int <- copy 1
-  {
-#?     print-int32-hex 0, x
-#?     print-string 0, "\n"
-    var tmp/edx: int <- copy _dr
-    tmp <- multiply x
-    compare tmp, _nr
-    break-if->
-    x <- shift-left 1
-    loop
-  }
-#?   print-string 0, "--\n"
-  # min, max = x/2, x
-  var max/ecx: int <- copy x
-  var min/edx: int <- copy max
-  min <- shift-right 1
-  # narrow down result between min and max
-  var i/eax: int <- copy min
-  {
-#?     print-int32-hex 0, i
-#?     print-string 0, "\n"
-    var foo/ebx: int <- copy _dr
-    foo <- multiply i
-    compare foo, _nr
-    break-if->
-    i <- increment
-    loop
-  }
-  result <- copy i
-  result <- decrement
-#?   print-string 0, "=> "
-#?   print-int32-hex 0, result
-#?   print-string 0, "\n"
-}
-
-fn test-try-divide-1 {
-  var result/eax: int <- try-divide 0, 2
-  check-ints-equal result, 0, "F - try-divide-1\n"
-}
-
-fn test-try-divide-2 {
-  var result/eax: int <- try-divide 1, 2
-  check-ints-equal result, 0, "F - try-divide-2\n"
-}
-
-fn test-try-divide-3 {
-  var result/eax: int <- try-divide 2, 2
-  check-ints-equal result, 1, "F - try-divide-3\n"
-}
-
-fn test-try-divide-4 {
-  var result/eax: int <- try-divide 4, 2
-  check-ints-equal result, 2, "F - try-divide-4\n"
-}
-
-fn test-try-divide-5 {
-  var result/eax: int <- try-divide 6, 2
-  check-ints-equal result, 3, "F - try-divide-5\n"
-}
-
-fn test-try-divide-6 {
-  var result/eax: int <- try-divide 9, 3
-  check-ints-equal result, 3, "F - try-divide-6\n"
-}
-
-fn test-try-divide-7 {
-  var result/eax: int <- try-divide 0xc, 4
-  check-ints-equal result, 3, "F - try-divide-7\n"
-}
-
-fn test-try-divide-8 {
-  var result/eax: int <- try-divide 0x1b, 3  # 27/3
-  check-ints-equal result, 9, "F - try-divide-8\n"
-}
-
-fn test-try-divide-9 {
-  var result/eax: int <- try-divide 0x1c, 3  # 28/3
-  check-ints-equal result, 9, "F - try-divide-9\n"
-}