From d211e09b0d14c21ef383e477f1d6f8ac37a1b69f Mon Sep 17 00:00:00 2001
From: Joe Bryan <joemfb@gmail.com>
Date: Fri, 5 Aug 2022 14:46:54 -0400
Subject: [PATCH 01/11] bump

---
 pkg/urbit/include/c/portable.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pkg/urbit/include/c/portable.h b/pkg/urbit/include/c/portable.h
index 10c2aa7107..8487dcb8df 100644
--- a/pkg/urbit/include/c/portable.h
+++ b/pkg/urbit/include/c/portable.h
@@ -158,24 +158,24 @@
 #     else
 #       define U3_OS_LoomBase 0x36000000
 #     endif
-#       define U3_OS_LoomBits 29
+#       define U3_OS_LoomBits 30
 #   elif defined(U3_OS_mingw)
 #       define U3_OS_LoomBase 0x28000000000
-#       define U3_OS_LoomBits 29
+#       define U3_OS_LoomBits 30
 #   elif defined(U3_OS_osx)
 #     ifdef __LP64__
 #       define U3_OS_LoomBase 0x28000000000
 #     else
 #       define U3_OS_LoomBase 0x4000000
 #     endif
-#       define U3_OS_LoomBits 29
+#       define U3_OS_LoomBits 30
 #   elif defined(U3_OS_bsd)
 #     ifdef __LP64__
 #       define U3_OS_LoomBase 0x200000000
 #     else
 #       define U3_OS_LoomBase 0x4000000
 #     endif
-#       define U3_OS_LoomBits 29
+#       define U3_OS_LoomBits 30
 #   else
 #     error "port: LoomBase"
 #   endif

From 29bce646696b8434d4597678ac7688fe261c45bc Mon Sep 17 00:00:00 2001
From: Joe Bryan <joemfb@gmail.com>
Date: Wed, 7 Sep 2022 10:21:22 -0400
Subject: [PATCH 02/11] ur: optimizes bitstream bytes-writer implementation

---
 pkg/urbit/ur/bitstream.c | 85 ++++++++++++++++++----------------------
 1 file changed, 39 insertions(+), 46 deletions(-)

diff --git a/pkg/urbit/ur/bitstream.c b/pkg/urbit/ur/bitstream.c
index dfc42393b7..0c3bec207e 100644
--- a/pkg/urbit/ur/bitstream.c
+++ b/pkg/urbit/ur/bitstream.c
@@ -1035,67 +1035,60 @@ ur_bsw64(ur_bsw_t *bsw, uint8_t len, uint64_t val)
 }
 
 static inline void
-_bsw_bytes_unsafe(ur_bsw_t *bsw, uint64_t len, uint8_t *byt)
+_bsw_bytes_unsafe(ur_bsw_t *bsw, const uint64_t len, const uint8_t* src)
 {
-  uint64_t len_byt = len >> 3;
-  uint8_t  len_bit = ur_mask_3(len);
-  uint64_t    fill = bsw->fill;
-  uint8_t      off = bsw->off;
+  uint64_t fill = bsw->fill;
+  uint8_t   off = bsw->off;
+  uint8_t  *dst = bsw->bytes + fill;
 
   if ( !off ) {
-    memcpy(bsw->bytes + fill, byt, len_byt);
-    fill += len_byt;
-    off   = len_bit;
+    const uint64_t len_byt = len >> 3;
+    const uint8_t  len_bit = ur_mask_3(len);
 
-    if ( off ) {
-      bsw->bytes[fill] = byt[len_byt] & ((1 << off) - 1);
+    memcpy(dst, src, len_byt);
+    bsw->fill = fill + len_byt;
+
+    if ( len_bit ) {
+      dst[len_byt] = src[len_byt] & ((1 << len_bit) - 1);
+      bsw->off = len_bit;
     }
   }
-  //  the least-significant bits of the input become the
-  //  most-significant bits of a byte in the output stream, and vice-versa
-  //
-  else {
-    uint8_t rest = 8 - off;
-    uint8_t mask = (1 << rest) - 1;
-    uint8_t l, m = bsw->bytes[fill];
-    uint64_t   i;
+  else  {
+    const uint8_t rest = 8 - off;
 
-    for ( i = 0; i < len_byt; i++ ) {
-      l = byt[i] & mask;
-      bsw->bytes[fill++] = m ^ (l << off);
-      m = byt[i] >> rest;
-    }
+    if ( rest >= len ) {
+      uint16_t ful = off + len;
 
-    //  no trailing bits; we need only write the rest of the last byte.
-    //
-    //    NB: while semantically equivalent to the subsequent block,
-    //    this case must be separate to avoid reading off the end of [byt]
-    //
-    if ( !len_bit ) {
-      bsw->bytes[fill] = m;
+      *dst ^= (*src & ((1 << len) - 1)) << off;
+
+      if ( ful >> 3 ) {
+        bsw->fill = fill + 1;
+      }
+
+      bsw->off = ur_mask_3(ful);
     }
-    //  trailing bits fit into the current output byte.
-    //
-    else if ( len_bit < rest ) {
-      l = byt[len_byt] & ((1 << len_bit) - 1);
-      bsw->bytes[fill] = m ^ (l << off);
-      off += len_bit;
-    }
-    //  trailing bits extend into the next output byte.
-    //
     else {
-      l = byt[len_byt] & mask;
-      bsw->bytes[fill++] = m ^ (l << off);
+      const uint64_t     nel = len - rest;
+      const uint64_t len_byt = nel >> 3;
+      const uint8_t  len_bit = ur_mask_3(nel);
 
-      m = byt[len_byt] >> rest;
+      *dst++ ^= *src << off;
 
-      off = len_bit - rest;
-      bsw->bytes[fill] = m & ((1 << off) - 1);
+      for ( uint64_t i = 0; i < len_byt; i++ ) {
+        dst[i] = (src[i] >> rest) ^ (src[i + 1] << off);
+      }
+
+      {
+        uint8_t  tal = (src[len_byt] >> rest)
+                     ^ (( off > len_bit ) ? 0 : (src[len_byt + 1] << off));
+        dst[len_byt] = tal & ((1 << len_bit) - 1);
+      }
+
+      bsw->fill = fill + len_byt + 1;
+      bsw->off  = len_bit;
     }
   }
 
-  bsw->off   = off;
-  bsw->fill  = fill;
   bsw->bits += len;
 }
 

From dbda9ed30c2eb4374fc95842123e85eb8b4b9fd4 Mon Sep 17 00:00:00 2001
From: Joe Bryan <joemfb@gmail.com>
Date: Wed, 14 Sep 2022 19:35:34 -0400
Subject: [PATCH 03/11] ur: optimizes bitstream bytes-reader implementation

---
 pkg/urbit/ur/bitstream.c | 24 ++++++++++--------------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/pkg/urbit/ur/bitstream.c b/pkg/urbit/ur/bitstream.c
index 0c3bec207e..5d69e3f9e7 100644
--- a/pkg/urbit/ur/bitstream.c
+++ b/pkg/urbit/ur/bitstream.c
@@ -411,25 +411,21 @@ ur_bsr_bytes_any(ur_bsr_t *bsr, uint64_t len, uint8_t *out)
     //
     else {
       uint8_t  rest = 8 - off;
-      uint8_t  mask = (1 << off) - 1;
-      uint8_t   byt, l, m = *b >> off;
       uint64_t last = left - 1;
+      uint64_t  max = ur_min(last, len_byt);
+      uint8_t  m, l;
 
       //  loop over all the bytes we need (or all that remain)
       //
-      //    [l] holds [off] bits
-      //    [m] holds [rest] bits
-      //
       {
-        uint64_t  max = ur_min(last, len_byt);
         uint64_t i;
 
         for ( i = 0; i < max; i++ ) {
-          byt    = *++b;
-          l      = byt & mask;
-          out[i] = m ^ (l << rest);
-          m      = byt >> off;
+          out[i] = (b[i] >> off) ^ (b[i + 1] << rest);
         }
+
+        b += max;
+        m = *b >> off;
       }
 
       //  we're reading into or beyond the last byte [bsr]
@@ -441,13 +437,13 @@ ur_bsr_bytes_any(ur_bsr_t *bsr, uint64_t len, uint8_t *out)
         uint8_t bits = len - (last << 3);
 
         if ( bits < rest ) {
-          out[last] = m & ((1 << bits) - 1);
+          out[max] = m & ((1 << len_bit) - 1);
           bsr->bytes = b;
           left = 1;
           off += len_bit;
         }
         else {
-          out[last] = m;
+          out[max] = m;
           bsr->bytes = 0;
           left = 0;
           off  = 0;
@@ -465,11 +461,11 @@ ur_bsr_bytes_any(ur_bsr_t *bsr, uint64_t len, uint8_t *out)
 
         if ( len_bit ) {
           if ( len_bit <= rest ) {
-            out[len_byt] = m & ((1 << len_bit) - 1);
+            out[max] = m & ((1 << len_bit) - 1);
           }
           else {
             l = *++b & ((1 << off) - 1);
-            out[len_byt] = m ^ (l << rest);
+            out[max] = (m ^ (l << rest)) & ((1 << len_bit) - 1);
           }
         }
       }

From 8946164b964fbcb235105b3288cd8c378180cba2 Mon Sep 17 00:00:00 2001
From: Joe Bryan <joemfb@gmail.com>
Date: Mon, 19 Sep 2022 23:32:15 -0400
Subject: [PATCH 04/11] Revert "test: move _test_lily into noun_tests"

This reverts commit 5825cbde71cda516f01f66c0e9eb82c468c382d0.
---
 pkg/urbit/tests/boot_tests.c | 68 ++++++++++++++++++++++++++++++++++++
 pkg/urbit/tests/noun_tests.c | 50 ++------------------------
 2 files changed, 70 insertions(+), 48 deletions(-)
 create mode 100644 pkg/urbit/tests/boot_tests.c

diff --git a/pkg/urbit/tests/boot_tests.c b/pkg/urbit/tests/boot_tests.c
new file mode 100644
index 0000000000..e353b04d54
--- /dev/null
+++ b/pkg/urbit/tests/boot_tests.c
@@ -0,0 +1,68 @@
+#include "all.h"
+#include "ur/ur.h"
+#include "vere/ivory.h"
+#include "vere/vere.h"
+
+/* _setup(): prepare for tests.
+*/
+static void
+_setup(void)
+{
+  c3_d          len_d = u3_Ivory_pill_len;
+  c3_y*         byt_y = u3_Ivory_pill;
+  u3_cue_xeno*  sil_u;
+  u3_weak       pil;
+
+  u3C.wag_w |= u3o_hashless;
+  u3m_boot_lite();
+  sil_u = u3s_cue_xeno_init_with(ur_fib27, ur_fib28);
+  if ( u3_none == (pil = u3s_cue_xeno_with(sil_u, len_d, byt_y)) ) {
+    printf("*** fail _setup 1\n");
+    exit(1);
+  }
+  u3s_cue_xeno_done(sil_u);
+  if ( c3n == u3v_boot_lite(pil) ) {
+    printf("*** fail _setup 2\n");
+    exit(1);
+  }
+}
+
+/* _test_lily(): test small noun parsing.
+*/
+static void
+_test_lily()
+{
+  c3_l    lit_l;
+  c3_w    big_w[] = {0, 0, 1};
+  u3_noun big = u3i_words(3, big_w);
+  u3_noun cod = u3dc("scot", c3__uv, big);
+
+  if ( c3y == u3v_lily(c3__uv, cod, &lit_l) ) {
+    printf("*** fail _test_lily-1\n");
+    exit(1);
+  }
+  cod = u3dc("scot", c3__ud, 0x7fffffff);
+  if ( (c3n == u3v_lily(c3__ud, cod, &lit_l)) ||
+       (0x7fffffff != lit_l) ) {
+    printf("*** fail _test_lily-2a\n");
+    exit(1);
+  }
+  cod = u3dc("scot", c3__ux, u3i_word(0x80000000));
+  if ( c3y == u3v_lily(c3__ux, cod, &lit_l) ) {
+    printf("*** fail _test_lily-2b\n");
+    exit(1);
+  }
+}
+
+/* main(): run all test cases.
+*/
+int
+main(int argc, char* argv[])
+{
+  _setup();
+
+  _test_lily();
+
+  fprintf(stderr, "test boot: ok\n");
+  return 0;
+}
diff --git a/pkg/urbit/tests/noun_tests.c b/pkg/urbit/tests/noun_tests.c
index b84b618652..b7233b1f49 100644
--- a/pkg/urbit/tests/noun_tests.c
+++ b/pkg/urbit/tests/noun_tests.c
@@ -1,7 +1,4 @@
 #include "all.h"
-#include "ur/ur.h"
-#include "vere/ivory.h"
-#include "vere/vere.h"
 
 #define TRUE 1
 #define FALSE 0
@@ -11,23 +8,8 @@
 static void
 _setup(void)
 {
-  c3_d          len_d = u3_Ivory_pill_len;
-  c3_y*         byt_y = u3_Ivory_pill;
-  u3_cue_xeno*  sil_u;
-  u3_weak       pil;
-
-  u3C.wag_w |= u3o_hashless;
-  u3m_boot_lite();
-  sil_u = u3s_cue_xeno_init_with(ur_fib27, ur_fib28);
-  if ( u3_none == (pil = u3s_cue_xeno_with(sil_u, len_d, byt_y)) ) {
-    printf("*** fail _setup 1\n");
-    exit(1);
-  }
-  u3s_cue_xeno_done(sil_u);
-  if ( c3n == u3v_boot_lite(pil) ) {
-    printf("*** fail _setup 2\n");
-    exit(1);
-  }
+  u3m_init();
+  u3m_pave(c3y);
 }
 
 /* _util_rand_string(): dynamically allocated len_w random string
@@ -1652,33 +1634,6 @@ _test_nvm_stack()
 #endif
 }
 
-/* _test_lily(): test small noun parsing.
-*/
-static void
-_test_lily()
-{
-  c3_l    lit_l;
-  c3_w    big_w[] = {0, 0, 1};
-  u3_noun big = u3i_words(3, big_w);
-  u3_noun cod = u3dc("scot", c3__uv, big);
-
-  if ( c3y == u3v_lily(c3__uv, cod, &lit_l) ) {
-    printf("*** fail _test_lily-1\n");
-    exit(1);
-  }
-  cod = u3dc("scot", c3__ud, 0x7fffffff);
-  if ( (c3n == u3v_lily(c3__ud, cod, &lit_l)) ||
-       (0x7fffffff != lit_l) ) {
-    printf("*** fail _test_lily-2a\n");
-    exit(1);
-  }
-  cod = u3dc("scot", c3__ux, u3i_word(0x80000000));
-  if ( c3y == u3v_lily(c3__ux, cod, &lit_l) ) {
-    printf("*** fail _test_lily-2b\n");
-    exit(1);
-  }
-}
-
 /* main(): run all test cases.
 */
 int
@@ -1698,7 +1653,6 @@ main(int argc, char* argv[])
   _test_cells_complex();
   _test_u3r_at();
   _test_nvm_stack();
-  _test_lily();
 
   fprintf(stderr, "test_noun: ok\n");
 

From 182e8813d08a06a3ee593c40fed34aaa2151368e Mon Sep 17 00:00:00 2001
From: Joe Bryan <joemfb@gmail.com>
Date: Wed, 14 Sep 2022 09:35:01 -0400
Subject: [PATCH 05/11] u3: rewrites u3r_chop(), optimizing bloq sizes < 5

---
 pkg/urbit/include/noun/retrieve.h |  44 ++-
 pkg/urbit/noun/retrieve.c         | 230 ++++++++---
 pkg/urbit/tests/noun_tests.c      | 626 ++++++++++++++++++------------
 3 files changed, 589 insertions(+), 311 deletions(-)

diff --git a/pkg/urbit/include/noun/retrieve.h b/pkg/urbit/include/noun/retrieve.h
index edd2275bfa..106ec6e828 100644
--- a/pkg/urbit/include/noun/retrieve.h
+++ b/pkg/urbit/include/noun/retrieve.h
@@ -362,18 +362,50 @@
         u3r_bytes_all(c3_w*   len_w,
                       u3_atom a);
 
+      /* u3r_chop_bits():
+      **
+      **   XOR `wid_d` bits from`src_w` at `bif_g` to `dst_w` at `bif_g`
+      **
+      **   NB: [dst_w] must have space for [bit_g + wid_d] bits
+      */
+        void
+        u3r_chop_bits(c3_g  bif_g,
+                      c3_d  wid_d,
+                      c3_g  bit_g,
+                      c3_w* dst_w,
+                const c3_w* src_w);
+
+      /* u3r_chop_words():
+      **
+      **   Into the bloq space of `met`, from position `fum` for a
+      **   span of `wid`, to position `tou`, XOR from `src_w`
+      **   into `dst_w`.
+      **
+      **   NB: [dst_w] must have space for [tou_w + wid_w] bloqs
+      */
+        void
+        u3r_chop_words(c3_g  met_g,
+                       c3_w  fum_w,
+                       c3_w  wid_w,
+                       c3_w  tou_w,
+                       c3_w* dst_w,
+                       c3_w  len_w,
+                 const c3_w* src_w);
+
       /* u3r_chop():
       **
       **   Into the bloq space of `met`, from position `fum` for a
       **   span of `wid`, to position `tou`, XOR from atom `src`
-      **   into ray `dst`.
+      **   into `dst_w`.
+      **
+      **   NB: [dst_w] must have space for [tou_w + wid_w] bloqs
       */
         void
-        u3r_chop(c3_g    met_g,
-                 c3_w    fum_w,
-                 c3_w    wid_w,
-                 c3_w    tou_w,
-                 c3_w*   dst_w,
+        u3r_chop(c3_g  met_g,
+                 c3_w  fum_w,
+                 c3_w  wid_w,
+                 c3_w  tou_w,
+                 c3_w* dst_w,
                  u3_atom src);
 
       /* u3r_mp():
diff --git a/pkg/urbit/noun/retrieve.c b/pkg/urbit/noun/retrieve.c
index 2a09ccd0e8..6df583d31f 100644
--- a/pkg/urbit/noun/retrieve.c
+++ b/pkg/urbit/noun/retrieve.c
@@ -1448,79 +1448,201 @@ u3r_safe_chub(u3_noun dat, c3_d* out_d)
   return c3y;
 }
 
+/* u3r_chop_bits():
+**
+**   XOR `wid_d` bits from`src_w` at `bif_g` to `dst_w` at `bif_g`
+**
+**   NB: [dst_w] must have space for [bit_g + wid_d] bits
+*/
+void
+u3r_chop_bits(c3_g  bif_g,
+              c3_d  wid_d,
+              c3_g  bit_g,
+              c3_w* dst_w,
+        const c3_w* src_w)
+{
+  c3_y fib_y = 32 - bif_g;
+  c3_y tib_y = 32 - bit_g;
+
+  //  we need to chop words
+  //
+  if ( wid_d >= tib_y ) {
+    //  align *dst_w
+    //
+    if ( bit_g ) {
+      c3_w low_w = src_w[0] >> bif_g;
+
+      if ( bif_g > bit_g ) {
+        low_w   ^= src_w[1] << fib_y;
+      }
+
+      *dst_w++  ^= low_w << bit_g;
+
+      wid_d -= tib_y;
+      bif_g += tib_y;
+      src_w += !!(bif_g >> 5);
+      bif_g &= 31;
+      fib_y  = 32 - bif_g;
+    }
+
+    {
+      size_t i_i, byt_i = wid_d >> 5;
+
+      if ( !bif_g ) {
+        for ( i_i = 0; i_i < byt_i; i_i++ ) {
+          dst_w[i_i] ^= src_w[i_i];
+        }
+      }
+      else {
+        for ( i_i = 0; i_i < byt_i; i_i++ ) {
+          dst_w[i_i] ^= (src_w[i_i] >> bif_g) ^ (src_w[i_i + 1] << fib_y);
+        }
+      }
+
+      src_w += byt_i;
+      dst_w += byt_i;
+      wid_d &= 31;
+      bit_g  = 0;
+    }
+  }
+
+  //  we need to chop (more) bits
+  //
+  if ( wid_d ) {
+    c3_w hig_w = src_w[0] >> bif_g;
+
+    if ( wid_d > fib_y ) {
+      hig_w   ^= src_w[1] << fib_y;
+    }
+
+    *dst_w    ^= (hig_w & ((1 << wid_d) - 1)) << bit_g;
+  }
+}
+
+/* u3r_chop_words():
+**
+**   Into the bloq space of `met`, from position `fum` for a
+**   span of `wid`, to position `tou`, XOR from `src_w`
+**   into `dst_w`.
+**
+**   NB: [dst_w] must have space for [tou_w + wid_w] bloqs
+*/
+void
+u3r_chop_words(c3_g  met_g,
+               c3_w  fum_w,
+               c3_w  wid_w,
+               c3_w  tou_w,
+               c3_w* dst_w,
+               c3_w  len_w,
+         const c3_w* src_w)
+{
+  //  operate on words
+  //
+  if ( met_g >= 5 ) {
+    size_t i_i, wid_i;
+
+    {
+      c3_g   hut_g = met_g - 5;
+      size_t fum_i = (size_t)fum_w << hut_g;
+      size_t tou_i = (size_t)tou_w << hut_g;
+      size_t tot_i;
+
+      wid_i = (size_t)wid_w << hut_g;
+      tot_i = fum_i + wid_i;
+
+      //  since [dst_w] must have space for (tou_w + wid_w) bloqs,
+      //  neither conversion can overflow
+      //
+      if ( (fum_i >> hut_g != fum_w) || (tot_i  - wid_i != fum_i) ) {
+        u3m_bail(c3__fail);
+        return;
+      }
+      else if ( fum_i >= len_w ) {
+        return;
+      }
+
+      if ( tot_i > len_w ) {
+        wid_i -= tot_i - len_w;
+      }
+
+      src_w += fum_i;
+      dst_w += tou_i;
+    }
+
+    for ( i_i = 0; i_i < wid_i; i_i++ ) {
+      dst_w[i_i] ^= src_w[i_i];
+    }
+  }
+  //  operate on bits
+  //
+  else {
+    c3_d wid_d = (c3_d)wid_w << met_g;
+    c3_g bif_g, bit_g;
+
+    {
+      c3_d len_d = (c3_d)len_w << 5;
+      c3_d fum_d = (c3_d)fum_w << met_g;
+      c3_d tou_d = (c3_d)tou_w << met_g;
+      c3_d tot_d = fum_d + wid_d;
+
+      // see above
+      //
+      if ( (fum_d >> met_g != fum_w) || (tot_d  - wid_d != fum_d) ) {
+        u3m_bail(c3__fail);
+        return;
+      }
+      else if ( fum_d > len_d ) {
+        return;
+      }
+
+      if ( tot_d > len_d ) {
+        wid_d -= tot_d - len_d;
+      }
+
+      src_w += fum_d >> 5;
+      dst_w += tou_d >> 5;
+      bif_g  = fum_d & 31;
+      bit_g  = tou_d & 31;
+    }
+
+    u3r_chop_bits(bif_g, wid_d, bit_g, dst_w, src_w);
+  }
+}
+
 /* u3r_chop():
 **
 **   Into the bloq space of `met`, from position `fum` for a
 **   span of `wid`, to position `tou`, XOR from atom `src`
 **   into `dst_w`.
+**
+**   NB: [dst_w] must have space for [tou_w + wid_w] bloqs
 */
 void
-u3r_chop(c3_g    met_g,
-           c3_w    fum_w,
-           c3_w    wid_w,
-           c3_w    tou_w,
-           c3_w*   dst_w,
-           u3_atom src)
+u3r_chop(c3_g  met_g,
+         c3_w  fum_w,
+         c3_w  wid_w,
+         c3_w  tou_w,
+         c3_w* dst_w,
+         u3_atom src)
 {
-  c3_w  i_w;
+  c3_w* src_w;
   c3_w  len_w;
-  c3_w* buf_w;
-
-  c3_assert(u3_none != src);
-  c3_assert(_(u3a_is_atom(src)));
 
   if ( _(u3a_is_cat(src)) ) {
     len_w = src ? 1 : 0;
-    buf_w = &src;
+    src_w = &src;
   }
   else {
     u3a_atom* src_u = u3a_to_ptr(src);
 
+    c3_assert(u3_none != src);
+    c3_assert(_(u3a_is_atom(src)));
+
     len_w = src_u->len_w;
-    buf_w = src_u->buf_w;
+    src_w = src_u->buf_w;
   }
 
-  if ( met_g < 5 ) {
-    c3_w san_w = (1 << met_g);
-    c3_w mek_w = ((1 << san_w) - 1);
-    c3_w baf_w = (fum_w << met_g);
-    c3_w bat_w = (tou_w << met_g);
-
-    // XX: efficiency: poor.  Iterate by words.
-    //
-    for ( i_w = 0; i_w < wid_w; i_w++ ) {
-      c3_w waf_w = (baf_w >> 5);
-      c3_g raf_g = (baf_w & 31);
-      c3_w wat_w = (bat_w >> 5);
-      c3_g rat_g = (bat_w & 31);
-      c3_w hop_w;
-
-      hop_w = (waf_w >= len_w) ? 0 : buf_w[waf_w];
-      hop_w = (hop_w >> raf_g) & mek_w;
-
-      dst_w[wat_w] ^= (hop_w << rat_g);
-
-      baf_w += san_w;
-      bat_w += san_w;
-    }
-  }
-  else {
-    c3_g hut_g = (met_g - 5);
-    c3_w san_w = (1 << hut_g);
-    c3_w j_w;
-
-    for ( i_w = 0; i_w < wid_w; i_w++ ) {
-      c3_w wuf_w = (fum_w + i_w) << hut_g;
-      c3_w wut_w = (tou_w + i_w) << hut_g;
-
-      for ( j_w = 0; j_w < san_w; j_w++ ) {
-        dst_w[wut_w + j_w] ^=
-            ((wuf_w + j_w) >= len_w)
-              ? 0
-              : buf_w[wuf_w + j_w];
-      }
-    }
-  }
+  u3r_chop_words(met_g, fum_w, wid_w, tou_w, dst_w, len_w, src_w);
 }
 
 /* u3r_string(): `a` as malloced C string.
diff --git a/pkg/urbit/tests/noun_tests.c b/pkg/urbit/tests/noun_tests.c
index b7233b1f49..cbfd76b417 100644
--- a/pkg/urbit/tests/noun_tests.c
+++ b/pkg/urbit/tests/noun_tests.c
@@ -12,6 +12,356 @@ _setup(void)
   u3m_pave(c3y);
 }
 
+/* _test_u3r_chop: "extract bit slices from atom"
+*/
+static c3_i
+_test_u3r_chop()
+{
+  c3_i  ret_i = 1;
+  c3_w  dst_w = 0;
+  u3_atom src = 0b11011;
+
+  //  bloq 0
+  //
+  {
+    //  read 1 bit from pos=0 (far right)
+    //
+    dst_w = 0;
+    u3r_chop(0, 0, 1, 0, &dst_w, src);
+    if ( 0x1 != dst_w ) {
+      fprintf(stderr, "test: u3r_chop: bloq 0, 0\r\n");
+      ret_i = 0;
+    }
+
+    //  read 1 bit from pos=1
+    //
+    dst_w = 0;
+    u3r_chop(0, 1, 1, 0, &dst_w, src);
+    if ( 0x1 != dst_w ) {
+      fprintf(stderr, "test: u3r_chop: bloq 0, 1\r\n");
+      ret_i = 0;
+    }
+
+    //  read 1 bit from pos=2
+    //
+    dst_w = 0;
+    u3r_chop(0, 2, 1, 0, &dst_w, src);
+    if ( 0x0 != dst_w ) {
+      fprintf(stderr, "test: u3r_chop: bloq 0, 2\r\n");
+      ret_i = 0;
+    }
+
+    //  read 4 x 1 bit bloq from pos=0
+    //
+    dst_w = 0;
+    u3r_chop(0, 0, 4, 0, &dst_w, src);
+    if ( 0b1011 != dst_w ) {
+      fprintf(stderr, "test: u3r_chop: bloq 0, 3\r\n");
+      ret_i = 0;
+    }
+
+    //  read 4 x 1 bit bloq from pos=0 into offset 1
+    //
+    dst_w = 0;
+    u3r_chop(0, 0, 4, 1, &dst_w, src);
+    if ( 0b10110 != dst_w ) {
+      fprintf(stderr, "test: u3r_chop: bloq 0, 4\r\n");
+      ret_i = 0;
+    }
+  }
+
+  //  bloq 1
+  //
+  {
+    //  read 2 bit from pos=0 (far right)
+    //
+    dst_w = 0;
+    u3r_chop(1, 0, 1, 0, &dst_w, src);
+    if ( 0b11 != dst_w ) {
+      fprintf(stderr, "test: u3r_chop: bloq 1, 0\r\n");
+      ret_i = 0;
+    }
+
+    //  read 2 bit from pos=1
+    //
+    dst_w = 0;
+    u3r_chop(1, 1, 1, 0, &dst_w, src);
+    if ( 0b10 != dst_w ) {
+      fprintf(stderr, "test: u3r_chop: bloq 1, 1\r\n");
+      ret_i = 0;
+    }
+
+    // read 2 bit from pos=2 (2 bloq over)
+    dst_w = 0;
+    u3r_chop(1, 2, 1, 0, &dst_w, src);
+    if ( 0b01 != dst_w ) {
+      fprintf(stderr, "test: u3r_chop: bloq 1, 2\r\n");
+      ret_i = 0;
+    }
+  }
+
+  //  bloq 3
+  {
+    dst_w = 0;
+    u3r_chop(3, 0, 1, 0, &dst_w, src);
+    if ( 0b11011 != dst_w ) {
+      fprintf(stderr, "test: u3r_chop: bloq 3, 0\r\n");
+      ret_i = 0;
+    }
+  }
+
+  //  read 1,8,16 bit bloqs from an indirect atom
+  //
+  {
+    src = u3i_string("abcdefghij");
+
+    //  1 bit pos=0 (far right)
+    //
+    dst_w = 0;
+    u3r_chop(0, 0, 1, 0, &dst_w, src);
+    if ( 0b1 != dst_w ) {
+      fprintf(stderr, "test: u3r_chop: indirect 0\r\n");
+      ret_i = 0;
+    }
+
+    //  8 bits pos=0
+    //
+    dst_w = 0;
+    u3r_chop(0, 0, 8, 0, &dst_w, src);
+    if ( 0b1100001 != dst_w ) {
+      fprintf(stderr, "test: u3r_chop: indirect 1\r\n");
+      ret_i = 0;
+    }
+
+    //  1 byte pos=0
+    //
+    dst_w = 0;
+    u3r_chop(3, 0, 1, 0, &dst_w, src);
+    if ( 0b1100001 != dst_w ) {
+      fprintf(stderr, "test: u3r_chop: indirect 2\r\n");
+      ret_i = 0;
+    }
+
+    //  1 short pos=0
+    //
+    dst_w = 0;
+    u3r_chop(4, 0, 1, 0, &dst_w, src);
+    if ( 0b0110001001100001 != dst_w ) {
+      fprintf(stderr, "test: u3r_chop: indirect 3\r\n");
+      ret_i = 0;
+    }
+
+    u3z(src);
+  }
+
+  // read lots of bits from a direct noun which holds 64 bits of data
+  // makes sure that we handle top 32 / bottom 32 correctly
+  {
+    c3_y inp_y[8] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
+    src = u3i_bytes(8, inp_y);
+
+    c3_w dst_w[2] = {0};
+    u3r_chop(0, 0, 63, 0, dst_w, src);
+    if ( (0x3020100 != dst_w[0]) || (0x7060504 != dst_w[1]) ) {
+      fprintf(stderr, "test: u3r_chop: indirect 4\r\n");
+      ret_i = 0;
+    }
+
+    u3z(src);
+  }
+
+  // as above (read lots of bits from a direct noun which holds 64 bits of data
+  // makes sure that we handle top 32 / bottom 32 correctly)
+  // but with a bit more nuance
+  {
+    c3_y inp_y[8] = { 0x0, 0x0, 0x0, 0xaa, 0xff, 0x0, 0x0, 0x0 };
+    src = u3i_bytes(8, (c3_y*)inp_y);
+
+    dst_w = 0;
+    u3r_chop(0, 24, 16, 0, &dst_w, src);
+    if ( 0b1111111110101010 != dst_w ) {
+      fprintf(stderr, "test: u3r_chop: indirect 5\r\n");
+      ret_i = 0;
+    }
+
+    u3z(src);
+  }
+
+  return ret_i;
+}
+
+/* _test_chop_slow(): "golden master" for chop tests (formerly u3r_chop())
+*/
+void
+_test_chop_slow(c3_g    met_g,
+                c3_w    fum_w,
+                c3_w    wid_w,
+                c3_w    tou_w,
+                c3_w*   dst_w,
+                c3_w    len_w,
+                c3_w*   buf_w)
+{
+  c3_w  i_w;
+
+  if ( met_g < 5 ) {
+    c3_w san_w = (1 << met_g);
+    c3_w mek_w = ((1 << san_w) - 1);
+    c3_w baf_w = (fum_w << met_g);
+    c3_w bat_w = (tou_w << met_g);
+
+    // XX: efficiency: poor.  Iterate by words.
+    //
+    for ( i_w = 0; i_w < wid_w; i_w++ ) {
+      c3_w waf_w = (baf_w >> 5);
+      c3_g raf_g = (baf_w & 31);
+      c3_w wat_w = (bat_w >> 5);
+      c3_g rat_g = (bat_w & 31);
+      c3_w hop_w;
+
+      hop_w = (waf_w >= len_w) ? 0 : buf_w[waf_w];
+      hop_w = (hop_w >> raf_g) & mek_w;
+
+      dst_w[wat_w] ^= (hop_w << rat_g);
+
+      baf_w += san_w;
+      bat_w += san_w;
+    }
+  }
+  else {
+    c3_g hut_g = (met_g - 5);
+    c3_w san_w = (1 << hut_g);
+    c3_w j_w;
+
+    for ( i_w = 0; i_w < wid_w; i_w++ ) {
+      c3_w wuf_w = (fum_w + i_w) << hut_g;
+      c3_w wut_w = (tou_w + i_w) << hut_g;
+
+      for ( j_w = 0; j_w < san_w; j_w++ ) {
+        dst_w[wut_w + j_w] ^=
+            ((wuf_w + j_w) >= len_w)
+              ? 0
+              : buf_w[wuf_w + j_w];
+      }
+    }
+  }
+}
+
+/* _test_chop_smol(): test permuations of chop from bloq 0-4
+*/
+static c3_i
+_test_chop_smol(c3_c* cap_c, c3_y val_y)
+{
+  c3_i ret_i = 1;
+  c3_g met_g;
+  c3_w fum_w, wid_w, tou_w;
+  c3_w len_w = 34;  //  (rsh [0 5] (mul 2 (mul 34 (bex 4))))
+  c3_w src_w[len_w];
+  c3_w   a_w[len_w];
+  c3_w   b_w[len_w];
+
+  memset(src_w, val_y, len_w << 2);
+
+  for ( met_g = 0; met_g < 5; met_g++ ) {
+    for ( fum_w = 0; fum_w <= len_w; fum_w++ ) {
+      for ( wid_w = 0; wid_w <= len_w; wid_w++ ) {
+        for ( tou_w = 0; tou_w <= len_w; tou_w++ ) {
+          memset(a_w, 0, len_w << 2);
+          memset(b_w, 0, len_w << 2);
+          u3r_chop_words(met_g, fum_w, wid_w, tou_w, a_w, len_w, src_w);
+          _test_chop_slow(met_g, fum_w, wid_w, tou_w, b_w, len_w, src_w);
+
+          if ( 0 != memcmp(a_w, b_w, len_w << 2) ) {
+            c3_g sif_g = 5 - met_g;
+            c3_w mas_w = (1 << met_g) - 1;
+            c3_w out_w = tou_w >> sif_g;
+            c3_w max_w = out_w + !!(fum_w & mas_w)
+                       + (wid_w >> sif_g) + !!(wid_w & mas_w);
+
+            fprintf(stderr, "%s (0x%x): met_g=%u fum_w=%u wid_w=%u tou_w=%u\r\n",
+                            cap_c, val_y,
+                            met_g, fum_w, wid_w, tou_w);
+
+
+            fprintf(stderr, "%u-%u: ", out_w, max_w - 1);
+            for ( ; out_w < max_w; out_w++ ) {
+              fprintf(stderr, "[0x%x 0x%x] ", a_w[out_w], b_w[out_w]);
+            }
+            fprintf(stderr, "\r\n");
+          }
+        }
+      }
+    }
+  }
+
+  return ret_i;
+}
+
+/* _test_chop_huge(): test permuations of chop from bloq 5+
+*/
+static c3_i
+_test_chop_huge(c3_c* cap_c, c3_y val_y)
+{
+  c3_i ret_i = 1;
+  c3_g met_g;
+  c3_w fum_w, wid_w, tou_w;
+  c3_w len_w = 192;  //   (rsh [0 5] (mul 2 (mul 3 (bex 10))))
+  c3_w src_w[len_w];
+  c3_w   a_w[len_w];
+  c3_w   b_w[len_w];
+
+  memset(src_w, val_y, len_w << 2);
+
+  for ( met_g = 5; met_g <= 10; met_g++ ) {
+    for ( fum_w = 0; fum_w <= 3; fum_w++ ) {
+      for ( wid_w = 0; wid_w <= 2; wid_w++ ) {
+        for ( tou_w = 0; tou_w <= 1; tou_w++ ) {
+          memset(a_w, 0, len_w << 2);
+          memset(b_w, 0, len_w << 2);
+          u3r_chop_words(met_g, fum_w, wid_w, tou_w, a_w, len_w, src_w);
+          _test_chop_slow(met_g, fum_w, wid_w, tou_w, b_w, len_w, src_w);
+
+          if ( 0 != memcmp(a_w, b_w, len_w << 2) ) {
+            c3_g sif_g = met_g - 5;
+            c3_w mas_w = (1 << met_g) - 1;
+            c3_w out_w = tou_w << sif_g;
+            c3_w max_w = out_w + !!(fum_w & mas_w)
+                       + (wid_w << sif_g) + !!(wid_w & mas_w);
+
+            fprintf(stderr, "%s (0x%x): met_g=%u fum_w=%u wid_w=%u tou_w=%u\r\n",
+                            cap_c, val_y,
+                            met_g, fum_w, wid_w, tou_w);
+
+
+            fprintf(stderr, "%u-%u: ", out_w, max_w - 1);
+            for ( ; out_w < max_w; out_w++ ) {
+              fprintf(stderr, "[0x%x 0x%x] ", a_w[out_w], b_w[out_w]);
+            }
+            fprintf(stderr, "\r\n");
+          }
+        }
+      }
+    }
+  }
+
+  return ret_i;
+}
+
+/* _test_u3r_chop(): bit slice XOR
+*/
+static c3_i
+_test_chop()
+{
+  return _test_u3r_chop()
+       & _test_chop_smol("chop smol zeros", 0x0)
+       & _test_chop_smol("chop smol ones", 0xff)
+       & _test_chop_smol("chop smol alt 1", 0xaa)
+       & _test_chop_smol("chop smol alt 2", 0x55)
+       & _test_chop_huge("chop huge zeros", 0x0)
+       & _test_chop_huge("chop huge ones", 0xff)
+       & _test_chop_huge("chop huge alt 1", 0xaa)
+       & _test_chop_huge("chop huge alt 2", 0x55);
+}
+
 /* _util_rand_string(): dynamically allocated len_w random string
 */
 static c3_y*
@@ -1247,256 +1597,6 @@ _test_u3r_at()
   if (bignum != ret) {  printf("*** u3r_at \n"); }
 }
 
-/* _test_u3r_chop: "extract bit slices from atom"
-*/
-static void
-_test_u3r_chop()
-{
-  c3_w   dst_w = 0;
-
-  // read 1 bit bloq
-  {
-    // read 1 bit from pos=0 (far right)
-    u3_atom src = 0b11011;
-
-    c3_g bloqsize_g = 0;
-
-
-    dst_w = 0;
-    u3r_chop(bloqsize_g,   /// bloq size
-             0,   // start index
-             1,   // count of bloqs
-             0,   // end index
-             & dst_w,   // where bytes go to
-             src);     // where bytes come from
-
-    if (0x1 != dst_w) {  printf("*** test_u3r_chop \n"); }
-
-
-    // read 1 bit from pos=1
-    dst_w = 0;
-    u3r_chop(bloqsize_g,   /// bloq size
-             1,   // start index
-             1,   // count of bloqs
-             0,   // end index
-             & dst_w,   // where bytes go to
-             src);     // where bytes come from
-
-    if (0x1 != dst_w) {  printf("*** test_u3r_chop 2\n"); }
-
-    // read 1 bit from pos=2
-    dst_w = 0;
-    u3r_chop(bloqsize_g,   /// bloq size
-             2,   // start index
-             1,   // count of bloqs
-             0,   // end index
-             & dst_w,   // where bytes go to
-             src);     // where bytes come from
-
-    if (0x0 != dst_w) {  printf("*** test_u3r_chop 3\n"); }
-
-    // read 4 x 1 bit bloq from pos=0
-    dst_w = 0;
-    u3r_chop(bloqsize_g,   /// bloq size
-             0,   // start index
-             4,   // count of bloqs
-             0,   // end index
-             & dst_w,   // where bytes go to
-             src);     // where bytes come from
-
-    if (0b1011 != dst_w) {  printf("*** test_u3r_chop 4\n"); }
-
-
-    // read 1 x 1 bit bloq from pos=0 into offset 1
-    dst_w = 0;
-    u3r_chop(bloqsize_g,   /// bloq size
-             0,   // start index
-             4,   // count of bloqs
-             1,   // end index
-             & dst_w,   // where bytes go to
-             src);     // where bytes come from
-
-    if (0b10110 != dst_w) {  printf("*** test_u3r_chop 5\n"); }
-
-
-
-  }
-
-  // read 2 bit bloq
-  {
-    u3_atom src = 0b11011;
-
-    c3_g bloqsize_g = 1;
-
-    // read 2 bit from pos=0 (far right)
-
-    dst_w = 0;
-    u3r_chop(bloqsize_g,   /// bloq size
-             0,   // start index
-             1,   // count of bloqs
-             0,   // end index
-             & dst_w,   // where bytes go to
-             src);     // where bytes come from
-
-    if (0b11 != dst_w) {  printf("*** test_u3r_chop 2.1\n"); }
-
-
-    // read 2 bit from pos=1 (1 bloq over )
-    dst_w = 0;
-    u3r_chop(bloqsize_g,   /// bloq size
-             1,   // start index
-             1,   // count of bloqs
-             0,   // end index
-             & dst_w,   // where bytes go to
-             src);     // where bytes come from
-
-    if (0b10 != dst_w) {  printf("*** test_u3r_chop 2.2\n"); }
-
-    // read 2 bit from pos=2 (2 bloq over)
-    dst_w = 0;
-    u3r_chop(bloqsize_g,   /// bloq size
-             2,   // start index
-             1,   // count of bloqs
-             0,   // end index
-             & dst_w,   // where bytes go to
-             src);     // where bytes come from
-
-    if (0b01 != dst_w) {  printf("*** test_u3r_chop 2.3\n"); }
-
-  }
-
-  // read 8 bit bloq
-  {
-    u3_atom src = 0b11011;
-
-    c3_g bloqsize_g = 3; // 2^3 = 8 bits
-
-    // pos=0 (far right)
-
-    dst_w = 0;
-    u3r_chop(bloqsize_g,   /// bloq size
-             0,   // start index
-             1,   // count of bloqs
-             0,   // end index
-             & dst_w,   // where bytes go to
-             src);     // where bytes come from
-
-    if (0b11011 != dst_w) {  printf("*** test_u3r_chop 8.1\n"); }
-  }
-
-  // read 1,8,16 bit bloqs from an indirect atom
-  {
-    // build an indirect noun 'src'
-
-    c3_c* input_c =  "abcdefghij";
-    u3_noun src = u3i_bytes(10, (c3_y*)input_c);
-
-
-    c3_g bloqsize_g = 0;  // 2^0 = 1 bit
-
-    // 1 x 1 bit pos=0 (far right)
-    dst_w = 0;
-    u3r_chop(bloqsize_g,   /// bloq size
-             0,   // start index
-             1,   // count of bloqs
-             0,   // end index
-             & dst_w,   // where bytes go to
-             src);     // where bytes come from
-
-    if (0b1 != dst_w) {
-      printf("*** test_u3r_chop indirect.1\n");
-    }
-
-    // 8 x 1 bit pos=0 (far right)
-    dst_w = 0;
-    u3r_chop(bloqsize_g,   /// bloq size
-             0,   // start index
-             8,   // count of bloqs
-             0,   // end index
-             & dst_w,   // where bytes go to
-             src);     // where bytes come from
-
-    if (0b1100001 != dst_w) {
-      printf("*** test_u3r_chop indirect.2\n");
-    }
-
-    // 1 x 1 byte = 8 bit, pos=0 (far right)
-    bloqsize_g = 3;  // 2^3 = 1 byte
-    dst_w = 0;
-    u3r_chop(bloqsize_g,   /// bloq size
-             0,   // start index
-             1,   // count of bloqs
-             0,   // end index
-             & dst_w,   // where bytes go to
-             src);     // where bytes come from
-
-    if (0b1100001 != dst_w) {
-      printf("*** test_u3r_chop indirect.3\n");
-    }
-
-    // 1 x 16 bit bloq, pos = 0
-    bloqsize_g = 4;  // 2^4 = 2 bytes
-
-    dst_w = 0;
-    u3r_chop(bloqsize_g,   /// bloq size
-             0,   // start index
-             1,   // count of bloqs
-             0,   // end index
-             & dst_w,   // where bytes go to
-             src);     // where bytes come from
-
-    if (0b0110001001100001 != dst_w) {
-      printf("*** test_u3r_chop indirect.4\n");
-    }
-  }
-
-  // read lots of bits from a direct noun which holds 64 bits of data
-  // makes sure that we handle top 32 / bottom 32 correctly
-  {
-    // build an indirect noun 'src'
-
-    c3_c input_c[8] =  { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
-    u3_noun src = u3i_bytes(8, (c3_y*)input_c);
-
-    c3_g bloqsize_g = 0;  // 2^0 = 1 bit
-
-    c3_w dst_w[2];
-    memset(dst_w, 0, 2 * sizeof(c3_w));
-
-    u3r_chop(bloqsize_g,   /// bloq size
-             0,       // start index
-             63,      // count of bloqs
-             0,       // offset on out index
-             dst_w,   // where bytes go to
-             src);    // where bytes come from
-
-  }
-
-  // as above (read lots of bits from a direct noun which holds 64 bits of data
-  // makes sure that we handle top 32 / bottom 32 correctly)
-  // but with a bit more nuance
-  {
-    //                   least significant                    most
-    c3_c input_c[8] =  { 0x0, 0x0, 0x0, 0xaa, 0xff, 0x0, 0x0, 0x0 };
-    u3_noun src = u3i_bytes(8, (c3_y*)input_c);
-
-    c3_g bloqsize_g = 0;  // 2^0 = 1 bit
-
-    c3_w dst_w = 0;
-
-    u3r_chop(bloqsize_g,   /// bloq size
-             24,       // start index
-             16,      // count of bloqs
-             0,       // offset on out index
-             & dst_w,   // where bytes go to
-             src);    // where bytes come from
-
-    if (0b1111111110101010 != dst_w) {
-      printf("*** test_u3r_chop indirect. 6\n");
-    }
-  }
-}
-
 //  XX disabled, static functions
 //
 #if 0
@@ -1634,6 +1734,19 @@ _test_nvm_stack()
 #endif
 }
 
+static c3_i
+_test_noun(void)
+{
+  c3_i ret_i = 1;
+
+  if ( !_test_chop() ) {
+    fprintf(stderr, "test noun: chop failed\r\n");
+    ret_i = 0;
+  }
+
+  return ret_i;
+}
+
 /* main(): run all test cases.
 */
 int
@@ -1641,9 +1754,20 @@ main(int argc, char* argv[])
 {
    _setup();
 
+  if ( !_test_noun() ) {
+    fprintf(stderr, "test noun: failed\r\n");
+    exit(1);
+  }
+
+  //  GC
+  //
+  u3m_grab(u3_none);
+
+  //  XX the following tests leak memory
+  //  fix and move to _test_noun()
+  //
   _test_noun_bits_set();
   _test_noun_bits_read();
-  _test_u3r_chop();
   _test_imprison();
   _test_imprison_complex();
   _test_sing();

From fd7e84e26d8d325609a73d92436d7b172ffa3697 Mon Sep 17 00:00:00 2001
From: Joe Bryan <joemfb@gmail.com>
Date: Fri, 5 Aug 2022 14:46:54 -0400
Subject: [PATCH 06/11] u3: bumps maximum reference bits on all platforms

---
 pkg/urbit/include/c/portable.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pkg/urbit/include/c/portable.h b/pkg/urbit/include/c/portable.h
index 83871d32f9..671db4d069 100644
--- a/pkg/urbit/include/c/portable.h
+++ b/pkg/urbit/include/c/portable.h
@@ -157,24 +157,24 @@
 #     else
 #       define U3_OS_LoomBase 0x36000000
 #     endif
-#       define U3_OS_LoomBits 29
+#       define U3_OS_LoomBits 30
 #   elif defined(U3_OS_mingw)
 #       define U3_OS_LoomBase 0x28000000000
-#       define U3_OS_LoomBits 29
+#       define U3_OS_LoomBits 30
 #   elif defined(U3_OS_osx)
 #     ifdef __LP64__
 #       define U3_OS_LoomBase 0x28000000000
 #     else
 #       define U3_OS_LoomBase 0x4000000
 #     endif
-#       define U3_OS_LoomBits 29
+#       define U3_OS_LoomBits 30
 #   elif defined(U3_OS_bsd)
 #     ifdef __LP64__
 #       define U3_OS_LoomBase 0x200000000
 #     else
 #       define U3_OS_LoomBase 0x4000000
 #     endif
-#       define U3_OS_LoomBits 29
+#       define U3_OS_LoomBits 30
 #   else
 #     error "port: LoomBase"
 #   endif

From 320740c5b9d41b739fa82e34c1af2f22dbba56d8 Mon Sep 17 00:00:00 2001
From: Joe Bryan <joemfb@gmail.com>
Date: Mon, 7 Nov 2022 10:10:35 -0500
Subject: [PATCH 07/11] vere: preserve 2GB defaults for --loom and --loom-urth

---
 pkg/urbit/daemon/main.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pkg/urbit/daemon/main.c b/pkg/urbit/daemon/main.c
index 486e496745..aad75fc3a6 100644
--- a/pkg/urbit/daemon/main.c
+++ b/pkg/urbit/daemon/main.c
@@ -167,8 +167,8 @@ _main_init(void)
   u3_Host.ops_u.hap_w = 50000;
   u3_Host.ops_u.kno_w = DefaultKernel;
 
-  u3_Host.ops_u.lut_y = u3a_bits + 2;
-  u3_Host.ops_u.lom_y = u3a_bits + 2;
+  u3_Host.ops_u.lut_y = u3a_bits + 1;
+  u3_Host.ops_u.lom_y = u3a_bits + 1;
 }
 
 /* _main_pier_run(): get pier from binary path (argv[0]), if appropriate

From f40db733ba4e8e42d33cfe0af29ad66c3e05a46b Mon Sep 17 00:00:00 2001
From: Joe Bryan <joemfb@gmail.com>
Date: Fri, 18 Nov 2022 17:44:46 -0500
Subject: [PATCH 08/11] vere: bumps version

---
 pkg/urbit/version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkg/urbit/version b/pkg/urbit/version
index 35d51f33b3..406c38ccd8 100644
--- a/pkg/urbit/version
+++ b/pkg/urbit/version
@@ -1 +1 @@
-1.12
\ No newline at end of file
+1.13-rc1
\ No newline at end of file

From 670ebc8f8c4a7bd83aba7fd1baffb7b4ba8af2a4 Mon Sep 17 00:00:00 2001
From: Joe Bryan <joemfb@gmail.com>
Date: Tue, 22 Nov 2022 15:23:29 -0500
Subject: [PATCH 09/11] vere: bumps benchmarks to 16MB loom, initializes guard
 page

---
 pkg/urbit/bench/ur_bench.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/pkg/urbit/bench/ur_bench.c b/pkg/urbit/bench/ur_bench.c
index 5ede7b5e92..4c01513576 100644
--- a/pkg/urbit/bench/ur_bench.c
+++ b/pkg/urbit/bench/ur_bench.c
@@ -7,8 +7,9 @@
 static void
 _setup(void)
 {
-  u3m_init(1 << 23);
+  u3m_init(1 << 24);
   u3m_pave(c3y);
+  u3e_init();
 }
 
 /* _ames_writ_ex(): |hi packet from fake ~zod to fake ~nec

From 2e861dafcf5fec839a1a0d65aca9712d7b4524d7 Mon Sep 17 00:00:00 2001
From: Joe Bryan <joemfb@gmail.com>
Date: Tue, 22 Nov 2022 15:38:15 -0500
Subject: [PATCH 10/11] vere: supports --loom in eval cmd

---
 pkg/urbit/daemon/main.c | 37 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 36 insertions(+), 1 deletion(-)

diff --git a/pkg/urbit/daemon/main.c b/pkg/urbit/daemon/main.c
index aad75fc3a6..1853ed8710 100644
--- a/pkg/urbit/daemon/main.c
+++ b/pkg/urbit/daemon/main.c
@@ -1213,6 +1213,41 @@ _cw_eval_get_input(FILE* fil_u, size_t siz_i)
 static void
 _cw_eval(c3_i argc, c3_c* argv[])
 {
+  c3_i ch_i, lid_i;
+  c3_w arg_w;
+
+  static struct option lop_u[] = {
+    { "loom", required_argument, NULL, c3__loom },
+    { NULL, 0, NULL, 0 }
+  };
+
+  while ( -1 != (ch_i=getopt_long(argc, argv, "", lop_u, &lid_i)) ) {
+    switch ( ch_i ) {
+      case c3__loom: {
+        c3_w lom_w;
+        c3_o res_o = _main_readw(optarg, u3a_bits + 3, &lom_w);
+        if ( (c3n == res_o) || (lom_w < 20) ) {
+          fprintf(stderr, "error: --loom must be >= 20 and <= %u\r\n", u3a_bits + 2);
+          exit(1);
+        }
+        u3_Host.ops_u.lom_y = lom_w;
+      } break;
+
+      case '?': {
+        fprintf(stderr, "invalid argument\r\n");
+        exit(1);
+      } break;
+    }
+  }
+
+  //  argv[optind] is always "eval"
+  //
+
+  if ( optind + 1 != argc ) {
+    fprintf(stderr, "invalid command\r\n");
+    exit(1);
+  }
+
   c3_c* evl_c = _cw_eval_get_input(stdin, 10);
 
   //  initialize the Loom and load the Ivory Pill
@@ -1224,7 +1259,7 @@ _cw_eval(c3_i argc, c3_c* argv[])
     u3_weak      pil;
 
     u3C.wag_w |= u3o_hashless;
-    u3m_boot_lite(u3a_bytes);
+    u3m_boot_lite((size_t)1 << u3_Host.ops_u.lom_y);
     sil_u = u3s_cue_xeno_init_with(ur_fib27, ur_fib28);
     if ( u3_none == (pil = u3s_cue_xeno_with(sil_u, len_d, byt_y)) ) {
       printf("lite: unable to cue ivory pill\r\n");

From dac240bdfa6e59fe00e0fdb10687f7058f22f787 Mon Sep 17 00:00:00 2001
From: Joe Bryan <joemfb@gmail.com>
Date: Wed, 23 Nov 2022 10:38:02 -0500
Subject: [PATCH 11/11] vere: bumps version

---
 pkg/urbit/version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkg/urbit/version b/pkg/urbit/version
index 406c38ccd8..9f76d37b71 100644
--- a/pkg/urbit/version
+++ b/pkg/urbit/version
@@ -1 +1 @@
-1.13-rc1
\ No newline at end of file
+1.13
\ No newline at end of file