claude is gud

36 files changed, 3585 insertions, 0 deletions

diff --git a/vere/pkg/noun/jets/c/aor.c b/vere/pkg/noun/jets/c/aor.c
new file mode 100644
index 0000000..248661e
--- /dev/null
+++ b/vere/pkg/noun/jets/c/aor.c
@@ -0,0 +1,69 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+  u3_noun
+  u3qc_aor(u3_noun a,
+           u3_noun b)
+  {
+    while ( 1 ) {
+      if ( c3y == u3r_sing(a, b) ) return c3y;
+      if ( c3n == u3ud(a) ) {
+        if ( c3y == u3ud(b) ) return c3n;
+        if ( c3y == u3r_sing(u3h(a), u3h(b)) ) {
+          a = u3t(a);
+          b = u3t(b);
+        }
+        else {
+          a = u3h(a);
+          b = u3h(b);
+        }
+      }
+      else {
+        if ( c3n == u3ud(b) ) return c3y;
+        {
+          c3_w len_a_w = u3r_met(3, a);
+          c3_w len_b_w = u3r_met(3, b);;
+          c3_y *buf_a_y, *buf_b_y;
+          c3_y cut_a_y, cut_b_y;
+          if ( c3y == u3a_is_cat(a) ) {
+            buf_a_y = (c3_y*)&a;
+          }
+          else {
+            u3a_atom* a_u = u3a_to_ptr(a);
+            buf_a_y = (c3_y*)(a_u->buf_w);
+          }
+          if ( c3y == u3a_is_cat(b) ) {
+            buf_b_y = (c3_y*)&b;
+          }
+          else {
+            u3a_atom* b_u = u3a_to_ptr(b);
+            buf_b_y = (c3_y*)(b_u->buf_w);
+          }
+          c3_w len_min_w = c3_min(len_a_w, len_b_w);
+          for (c3_w i_w = 0; i_w < len_min_w; i_w++) {
+            cut_a_y = buf_a_y[i_w];
+            cut_b_y = buf_b_y[i_w];
+            if ( cut_a_y != cut_b_y ) return __(cut_a_y < cut_b_y);
+          }
+          return __(len_a_w < len_b_w);
+        }
+      }
+    }
+  } 
+  
+  u3_noun
+  u3wc_aor(u3_noun cor)
+  {
+    u3_noun a, b;
+
+    if ( c3n == u3r_mean(cor, u3x_sam_2, &a, u3x_sam_3, &b, 0) ) {
+      return u3m_bail(c3__exit);
+    } else {
+      return u3qc_aor(a, b);
+    }
+  }
+
diff --git a/vere/pkg/noun/jets/c/bex.c b/vere/pkg/noun/jets/c/bex.c
new file mode 100644
index 0000000..497ebfd
--- /dev/null
+++ b/vere/pkg/noun/jets/c/bex.c
@@ -0,0 +1,55 @@
+/// @file
+
+#include "jets/k.h"
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+u3_noun
+u3qc_bex(u3_atom a)
+{
+  c3_d a_d;
+  u3i_slab sab_u;
+
+  if ( a < 31 ) {
+    return 1U << a;
+  }
+
+  if ( c3y == u3a_is_cat(a) ) {
+    a_d = a;
+  }
+  else {
+    if ( c3n == u3r_safe_chub(a, &a_d) ) {
+      return u3m_bail(c3__fail);
+    }
+
+    // We don't currently support atoms 2GB or larger (fails while
+    // mugging).  The extra term of 16 is experimentally determined.
+    if ( a_d >= ((c3_d)1 << (c3_d)34) - 16 ) {
+      u3l_log("bex: overflow");
+      return u3m_bail(c3__fail);
+    }
+  }
+
+  u3i_slab_init(&sab_u, 0, a_d + 1);
+
+  sab_u.buf_w[a_d >> 5] = 1U << (a_d & 31);
+
+  return u3i_slab_moot(&sab_u);
+}
+
+u3_noun
+u3kc_bex(u3_atom a)
+{
+  u3_noun b = u3qc_bex(a);
+  u3z(a);
+  return b;
+}
+
+u3_noun
+u3wc_bex(u3_noun cor)
+{
+  u3_noun a = u3x_at(u3x_sam, cor);
+  return u3qc_bex(u3x_atom(a));
+}
diff --git a/vere/pkg/noun/jets/c/c0n.c b/vere/pkg/noun/jets/c/c0n.c
new file mode 100644
index 0000000..a6fee5b
--- /dev/null
+++ b/vere/pkg/noun/jets/c/c0n.c
@@ -0,0 +1,55 @@
+/// @file
+
+#include "jets/k.h"
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+
+  u3_noun
+  u3qc_con(u3_atom a,
+           u3_atom b)
+  {
+    c3_w lna_w = u3r_met(5, a);
+    c3_w lnb_w = u3r_met(5, b);
+
+    if ( (lna_w == 0) && (lnb_w == 0) ) {
+      return 0;
+    }
+    else {
+      c3_w     len_w = c3_max(lna_w, lnb_w);
+      c3_w       i_w;
+      u3i_slab sab_u;
+      u3i_slab_from(&sab_u, a, 5, len_w);
+
+      for ( i_w = 0; i_w < lnb_w; i_w++ ) {
+        sab_u.buf_w[i_w] |= u3r_word(i_w, b);
+      }
+
+      return u3i_slab_mint(&sab_u);
+    }
+  }
+  u3_noun
+  u3wc_con(u3_noun cor)
+  {
+    u3_noun a, b;
+
+    if ( (c3n == u3r_mean(cor, u3x_sam_2, &a, u3x_sam_3, &b, 0)) ||
+         (c3n == u3ud(a)) ||
+         (c3n == u3ud(b)) )
+    {
+      return u3m_bail(c3__exit);
+    } else {
+      return u3qc_con(a, b);
+    }
+  }
+
+u3_noun
+u3kc_con(u3_noun a,
+         u3_noun b)
+{
+  u3_noun c = u3qc_con(a, b);
+  u3z(a); u3z(b);
+  return c;
+}
diff --git a/vere/pkg/noun/jets/c/can.c b/vere/pkg/noun/jets/c/can.c
new file mode 100644
index 0000000..ca6d97a
--- /dev/null
+++ b/vere/pkg/noun/jets/c/can.c
@@ -0,0 +1,85 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+
+  u3_noun
+  u3qc_can(u3_atom a,
+           u3_noun b)
+  {
+    if ( !_(u3a_is_cat(a)) || (a >= 32) ) {
+      return u3m_bail(c3__fail);
+    }
+    else {
+      c3_g       a_g = a;
+      c3_w     tot_w = 0;
+      u3i_slab sab_u;
+
+      /* Measure and validate the slab required.
+      */
+      {
+        u3_noun cab = b;
+
+        while ( 1 ) {
+          u3_noun i_cab, pi_cab, qi_cab;
+
+          if ( 0 == cab ) {
+            break;
+          }
+          if ( c3n == u3du(cab) ) return u3m_bail(c3__fail);
+          i_cab = u3h(cab);
+          if ( c3n == u3du(i_cab) ) return u3m_bail(c3__fail);
+          pi_cab = u3h(i_cab);
+          qi_cab = u3t(i_cab);
+          if ( c3n == u3a_is_cat(pi_cab) ) return u3m_bail(c3__fail);
+          if ( c3n == u3ud(qi_cab) )  return u3m_bail(c3__fail);
+          if ( (tot_w + pi_cab) < tot_w ) return u3m_bail(c3__fail);
+
+          tot_w += pi_cab;
+          cab = u3t(cab);
+        }
+
+        if ( 0 == tot_w ) {
+          return 0;
+        }
+
+        u3i_slab_init(&sab_u, a_g, tot_w);
+      }
+
+      /* Chop the list atoms in.
+      */
+      {
+        u3_noun cab = b;
+        c3_w    pos_w = 0;
+
+        while ( 0 != cab ) {
+          u3_noun i_cab = u3h(cab);
+          u3_atom pi_cab = u3h(i_cab);
+          u3_atom qi_cab = u3t(i_cab);
+
+          u3r_chop(a_g, 0, pi_cab, pos_w, sab_u.buf_w, qi_cab);
+          pos_w += pi_cab;
+          cab = u3t(cab);
+        }
+      }
+
+      return u3i_slab_mint(&sab_u);
+    }
+  }
+  u3_noun
+  u3wc_can(u3_noun cor)
+  {
+    u3_noun a, b;
+
+    if ( (c3n == u3r_mean(cor, u3x_sam_2, &a, u3x_sam_3, &b, 0)) ||
+         (c3n == u3ud(a)) )
+    {
+      return u3m_bail(c3__fail);
+    } else {
+      return u3qc_can(a, b);
+    }
+  }
+
diff --git a/vere/pkg/noun/jets/c/cap.c b/vere/pkg/noun/jets/c/cap.c
new file mode 100644
index 0000000..95bef1f
--- /dev/null
+++ b/vere/pkg/noun/jets/c/cap.c
@@ -0,0 +1,25 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+u3_noun
+u3qc_cap(u3_atom a)
+{
+  c3_w met_w = u3r_met(0, a);
+
+  if ( 2 > met_w ) {
+    return u3m_bail(c3__exit);
+  }
+  else {
+    return 2 + u3r_bit((met_w - 2), a);
+  }
+}
+
+u3_noun
+u3wc_cap(u3_noun cor)
+{
+  return u3qc_cap(u3x_atom(u3x_at(u3x_sam, cor)));
+}
diff --git a/vere/pkg/noun/jets/c/cat.c b/vere/pkg/noun/jets/c/cat.c
new file mode 100644
index 0000000..f3c4d2d
--- /dev/null
+++ b/vere/pkg/noun/jets/c/cat.c
@@ -0,0 +1,54 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+
+  u3_noun
+  u3qc_cat(u3_atom a,
+           u3_atom b,
+           u3_atom c)
+  {
+    if ( !_(u3a_is_cat(a)) || (a >= 32) ) {
+      return u3m_bail(c3__fail);
+    }
+    else {
+      c3_g   a_g = a;
+      c3_w   lew_w = u3r_met(a_g, b);
+      c3_w   ler_w = u3r_met(a_g, c);
+      c3_w   all_w = (lew_w + ler_w);
+
+      if ( 0 == all_w ) {
+        return 0;
+      }
+      else {
+        u3i_slab sab_u;
+        u3i_slab_from(&sab_u, b, a_g, all_w);
+
+        u3r_chop(a_g, 0, ler_w, lew_w, sab_u.buf_w, c);
+
+        return u3i_slab_mint(&sab_u);
+      }
+    }
+  }
+
+  u3_noun
+  u3wc_cat(u3_noun cor)
+  {
+    u3_noun a, b, c;
+
+    if ( (c3n == u3r_mean(cor, u3x_sam_2, &a,
+                                u3x_sam_6, &b,
+                                u3x_sam_7, &c, 0)) ||
+         (c3n == u3ud(a)) ||
+         (c3n == u3ud(b)) ||
+         (c3n == u3ud(c)) )
+    {
+      return u3m_bail(c3__exit);
+    } else {
+      return u3qc_cat(a, b, c);
+    }
+  }
+
diff --git a/vere/pkg/noun/jets/c/clz.c b/vere/pkg/noun/jets/c/clz.c
new file mode 100644
index 0000000..f8da45a
--- /dev/null
+++ b/vere/pkg/noun/jets/c/clz.c
@@ -0,0 +1,75 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+u3_atom
+u3qc_clz(u3_atom boq, u3_atom sep, u3_atom a)
+{
+  if ( !_(u3a_is_cat(boq)) || (boq >= 32) ) {
+    return u3m_bail(c3__fail);
+  }
+
+  if ( !_(u3a_is_cat(sep)) ) {
+    return u3m_bail(c3__fail);
+  }
+
+  c3_g boq_g = boq;
+  c3_w sep_w = sep;
+  c3_w tot_w = sep_w << boq_g;
+
+  if ( (tot_w >> boq_g) != sep_w ) {
+    return u3m_bail(c3__fail);
+  }
+
+  c3_w met_w = u3r_met(0, a);
+
+  if ( met_w <= tot_w ) {
+    tot_w -= met_w;
+    return u3i_word(tot_w);
+  }
+  else {
+    c3_w wid_w = tot_w >>  5;
+    c3_w bit_w = tot_w  & 31;
+    c3_w wor_w;
+
+    if ( bit_w ) {
+      wor_w  = u3r_word(wid_w, a);
+      wor_w &= (1 << bit_w) - 1;
+
+      if ( wor_w ) {
+        return bit_w - (32 - c3_lz_w(wor_w));
+      }
+    }
+
+    while ( wid_w-- ) {
+      wor_w = u3r_word(wid_w, a);
+
+      if ( wor_w ) {
+        bit_w += c3_lz_w(wor_w);
+        break;
+      }
+
+      bit_w += 32;
+    }
+
+    return u3i_word(bit_w);
+  }
+}
+
+u3_noun
+u3wc_clz(u3_noun cor)
+{
+  u3_atom boq, sep, vat;
+  {
+    u3_noun sam = u3h(u3t(cor));
+    u3_noun bit = u3h(sam);
+
+    u3x_bite(bit, &boq, &sep);
+    vat = u3x_atom(u3t(sam));
+  }
+
+  return u3qc_clz(boq, sep, vat);
+}
diff --git a/vere/pkg/noun/jets/c/ctz.c b/vere/pkg/noun/jets/c/ctz.c
new file mode 100644
index 0000000..ff74e24
--- /dev/null
+++ b/vere/pkg/noun/jets/c/ctz.c
@@ -0,0 +1,34 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+u3_atom
+u3qc_ctz(u3_atom a)
+{
+  c3_w wor_w, i_w = 0;
+
+  if ( 0 == a ) {
+    return 0;
+  }
+
+  do {
+    wor_w = u3r_word(i_w++, a);
+  }
+  while ( !wor_w );
+
+  {
+    c3_w bit_d = i_w - 1;
+    bit_d *= 32;
+    bit_d += c3_tz_w(wor_w);
+    return u3i_chub(bit_d);
+  }
+}
+
+u3_noun
+u3wc_ctz(u3_noun cor)
+{
+  return u3qc_ctz(u3x_atom(u3h(u3t(cor))));
+}
diff --git a/vere/pkg/noun/jets/c/cut.c b/vere/pkg/noun/jets/c/cut.c
new file mode 100644
index 0000000..43ed8c4
--- /dev/null
+++ b/vere/pkg/noun/jets/c/cut.c
@@ -0,0 +1,68 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+
+  u3_noun
+  u3qc_cut(u3_atom a,
+           u3_atom b,
+           u3_atom c,
+           u3_atom d)
+  {
+    c3_w b_w, c_w;
+    if ( !_(u3a_is_cat(a)) || (a >= 32) ) {
+      return u3m_bail(c3__fail);
+    }
+    if ( !_(u3r_safe_word(b, &b_w)) ) {
+      return u3m_bail(c3__fail);
+    }
+    if ( !_(u3r_safe_word(c, &c_w)) ) {
+      return u3m_bail(c3__fail);
+    }
+
+    {
+      c3_g a_g   = a;
+      c3_w len_w = u3r_met(a_g, d);
+
+      if ( (0 == c_w) || (b_w >= len_w) ) {
+        return 0;
+      }
+      if ( b_w + c_w > len_w ) {
+        c_w = (len_w - b_w);
+      }
+      if ( (b_w == 0) && (c_w == len_w) ) {
+        return u3k(d);
+      }
+      else {
+        u3i_slab sab_u;
+        u3i_slab_init(&sab_u, a_g, c_w);
+
+        u3r_chop(a_g, b_w, c_w, 0, sab_u.buf_w, d);
+
+        return u3i_slab_mint(&sab_u);
+      }
+    }
+  }
+  u3_noun
+  u3wc_cut(u3_noun cor)
+  {
+    u3_noun a, b, c, d;
+
+    if ( (c3n == u3r_mean(cor, u3x_sam_2,  &a,
+                                u3x_sam_12, &b,
+                                u3x_sam_13, &c,
+                                u3x_sam_7,  &d, 0)) ||
+         (c3n == u3ud(a)) ||
+         (c3n == u3ud(b)) ||
+         (c3n == u3ud(c)) ||
+         (c3n == u3ud(d)) )
+    {
+      return u3m_bail(c3__exit);
+    } else {
+      return u3qc_cut(a, b, c, d);
+    }
+  }
+
diff --git a/vere/pkg/noun/jets/c/dis.c b/vere/pkg/noun/jets/c/dis.c
new file mode 100644
index 0000000..8c41a36
--- /dev/null
+++ b/vere/pkg/noun/jets/c/dis.c
@@ -0,0 +1,46 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+
+  u3_noun
+  u3qc_dis(u3_atom a,
+           u3_atom b)
+  {
+    c3_w lna_w = u3r_met(5, a);
+    c3_w lnb_w = u3r_met(5, b);
+
+    if ( (lna_w == 0) && (lnb_w == 0) ) {
+      return 0;
+    }
+    else {
+      c3_w     len_w = c3_max(lna_w, lnb_w);
+      c3_w       i_w;
+      u3i_slab sab_u;
+      u3i_slab_from(&sab_u, a, 5, len_w);
+
+      for ( i_w = 0; i_w < len_w; i_w++ ) {
+        sab_u.buf_w[i_w] &= u3r_word(i_w, b);
+      }
+
+      return u3i_slab_mint(&sab_u);
+    }
+  }
+  u3_noun
+  u3wc_dis(u3_noun cor)
+  {
+    u3_noun a, b;
+
+    if ( (c3n == u3r_mean(cor, u3x_sam_2, &a, u3x_sam_3, &b, 0)) ||
+         (c3n == u3ud(a)) ||
+         (c3n == u3ud(b)) )
+    {
+      return u3m_bail(c3__exit);
+    } else {
+      return u3qc_dis(a, b);
+    }
+  }
+
diff --git a/vere/pkg/noun/jets/c/dor.c b/vere/pkg/noun/jets/c/dor.c
new file mode 100644
index 0000000..0c1e220
--- /dev/null
+++ b/vere/pkg/noun/jets/c/dor.c
@@ -0,0 +1,49 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+
+  u3_noun
+  u3qc_dor(u3_noun a,
+           u3_noun b)
+  {
+    if ( c3y == u3r_sing(a, b) ) {
+      return c3y;
+    }
+    else {
+      if ( c3y == u3ud(a) ) {
+        if ( c3y == u3ud(b) ) {
+          return u3qa_lth(a, b);
+        }
+        else {
+          return c3y;
+        }
+      }
+      else {
+        if ( c3y == u3ud(b) ) {
+          return c3n;
+        }
+        else {
+          if ( c3y == u3r_sing(u3h(a), u3h(b)) ) {
+            return u3qc_dor(u3t(a), u3t(b));
+          }
+          else return u3qc_dor(u3h(a), u3h(b));
+        }
+      }
+    }
+  }
+  u3_noun
+  u3wc_dor(u3_noun cor)
+  {
+    u3_noun a, b;
+
+    if ( c3n == u3r_mean(cor, u3x_sam_2, &a, u3x_sam_3, &b, 0) ) {
+      return u3m_bail(c3__exit);
+    } else {
+      return u3qc_dor(a, b);
+    }
+  }
+
diff --git a/vere/pkg/noun/jets/c/dvr.c b/vere/pkg/noun/jets/c/dvr.c
new file mode 100644
index 0000000..d822bf3
--- /dev/null
+++ b/vere/pkg/noun/jets/c/dvr.c
@@ -0,0 +1,46 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+
+  u3_noun
+  u3qc_dvr(u3_atom a,
+           u3_atom b)
+  {
+    if ( 0 == b ) {
+      return u3m_error("divide-by-zero");
+    }
+    else {
+      if ( _(u3a_is_cat(a)) && _(u3a_is_cat(b)) ) {
+        return u3nc(a / b, a % b);
+      }
+      else {
+        mpz_t a_mp, b_mp;
+
+        u3r_mp(a_mp, a);
+        u3r_mp(b_mp, b);
+
+        mpz_tdiv_qr(a_mp, b_mp, a_mp, b_mp);
+
+        return u3nc(u3i_mp(a_mp), u3i_mp(b_mp));
+      }
+    }
+  }
+  u3_noun
+  u3wc_dvr(u3_noun cor)
+  {
+    u3_noun a, b;
+
+    if ( (c3n == u3r_mean(cor, u3x_sam_2, &a, u3x_sam_3, &b, 0)) ||
+         (c3n == u3ud(a)) ||
+         (c3n == u3ud(b)) )
+    {
+      return u3m_bail(c3__fail);
+    } else {
+      return u3qc_dvr(a, b);
+    }
+  }
+
diff --git a/vere/pkg/noun/jets/c/end.c b/vere/pkg/noun/jets/c/end.c
new file mode 100644
index 0000000..94618ad
--- /dev/null
+++ b/vere/pkg/noun/jets/c/end.c
@@ -0,0 +1,51 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+u3_noun
+u3qc_end(u3_atom a,
+         u3_atom b,
+         u3_atom c)
+{
+  if ( !_(u3a_is_cat(a)) || (a >= 32) ) {
+    return u3m_bail(c3__fail);
+  }
+  else if ( !_(u3a_is_cat(b)) ) {
+    return u3k(c);
+  }
+  else {
+    c3_g a_g   = a;
+    c3_w b_w   = b;
+    c3_w len_w = u3r_met(a_g, c);
+
+    if ( 0 == b_w ) {
+      return 0;
+    }
+    else if ( b_w >= len_w ) {
+      return u3k(c);
+    }
+    else {
+      u3i_slab sab_u;
+      u3i_slab_init(&sab_u, a_g, b_w);
+
+      u3r_chop(a_g, 0, b_w, 0, sab_u.buf_w, c);
+
+      return u3i_slab_mint(&sab_u);
+    }
+  }
+}
+
+u3_noun
+u3wc_end(u3_noun cor)
+{
+  u3_atom bloq, step;
+  u3_noun a, b;
+  u3x_mean(cor, u3x_sam_2, &a,
+                u3x_sam_3, &b, 0);
+  u3x_bite(a, &bloq, &step);
+
+  return u3qc_end(bloq, step, u3x_atom(b));
+}
diff --git a/vere/pkg/noun/jets/c/gor.c b/vere/pkg/noun/jets/c/gor.c
new file mode 100644
index 0000000..91c2d98
--- /dev/null
+++ b/vere/pkg/noun/jets/c/gor.c
@@ -0,0 +1,32 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+
+  u3_noun
+  u3qc_gor(u3_noun a,
+           u3_noun b)
+  {
+    c3_w c_w = u3r_mug(a);
+    c3_w d_w = u3r_mug(b);
+
+    if ( c_w == d_w ) {
+      return u3qc_dor(a, b);
+    }
+    else return (c_w < d_w) ? c3y : c3n;
+  }
+  u3_noun
+  u3wc_gor(u3_noun cor)
+  {
+    u3_noun a, b;
+
+    if ( (c3n == u3r_mean(cor, u3x_sam_2, &a, u3x_sam_3, &b, 0)) ) {
+      return u3m_bail(c3__exit);
+    } else {
+      return u3qc_gor(a, b);
+    }
+  }
+
diff --git a/vere/pkg/noun/jets/c/ham.c b/vere/pkg/noun/jets/c/ham.c
new file mode 100644
index 0000000..776cf0c
--- /dev/null
+++ b/vere/pkg/noun/jets/c/ham.c
@@ -0,0 +1,27 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+u3_atom
+u3qc_ham(u3_atom a)
+{
+  c3_w len_w = u3r_met(5, a);
+  c3_d pop_d = 0;
+  c3_w wor_w;
+
+  for ( c3_w i_w = 0; i_w < len_w; i_w++ ) {
+    wor_w  = u3r_word(i_w, a);
+    pop_d += c3_pc_w(wor_w);
+  }
+
+  return u3i_chub(pop_d);
+}
+
+u3_noun
+u3wc_ham(u3_noun cor)
+{
+  return u3qc_ham(u3x_atom(u3h(u3t(cor))));
+}
diff --git a/vere/pkg/noun/jets/c/hew.c b/vere/pkg/noun/jets/c/hew.c
new file mode 100644
index 0000000..be6b7a7
--- /dev/null
+++ b/vere/pkg/noun/jets/c/hew.c
@@ -0,0 +1,87 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+static c3_w
+_hew_in(c3_g     a_g,
+        c3_w   pos_w,
+        u3_atom  vat,
+        u3_noun  sam,
+        u3_noun* out)
+{
+  u3_noun h, t, *l, *r;
+
+  while ( c3y == u3r_cell(sam, &h, &t) ) {
+    *out  = u3i_defcons(&l, &r);
+    pos_w = _hew_in(a_g, pos_w, vat, h, l);
+    sam   = t;
+    out   = r;
+  }
+
+  if ( !_(u3a_is_cat(sam)) ) {
+    return u3m_bail(c3__fail);
+  }
+
+  if ( !sam ) {
+    *out = 0;
+    return pos_w;
+  }
+  else {
+    c3_w     wid_w = (c3_w)sam;
+    c3_w     new_w = pos_w + wid_w;
+    u3i_slab sab_u;
+
+    if ( new_w < pos_w ) {
+      return u3m_bail(c3__fail);
+    }
+
+    u3i_slab_init(&sab_u, a_g, wid_w);
+    u3r_chop(a_g, pos_w, wid_w, 0, sab_u.buf_w, vat);
+
+    *out = u3i_slab_mint(&sab_u);
+    return new_w;
+  }
+}
+
+u3_noun
+u3qc_hew(u3_atom boq,
+         u3_atom sep,
+         u3_atom vat,
+         u3_noun sam)
+{
+  if ( !_(u3a_is_cat(boq)) || (boq >= 32) ) {
+    return u3m_bail(c3__fail);
+  }
+
+  if ( !_(u3a_is_cat(sep)) ) {
+    return u3m_bail(c3__fail);
+  }
+
+  u3_noun pro;
+  c3_w  pos_w = _hew_in((c3_g)boq, (c3_w)sep, vat, sam, &pro);
+  return u3nt(pro, boq, u3i_word(pos_w));
+}
+
+u3_noun
+u3wc_hew(u3_noun cor)
+{
+  u3_atom boq, sep, vat;
+  u3_noun sam;
+  {
+    u3_noun pay = u3t(cor);
+    u3_noun con = u3t(pay);
+    u3_noun gat = u3t(con);       // outer gate
+    u3_noun cam = u3h(u3t(gat));  // outer sample
+    u3_noun   d = u3h(con);
+
+    boq = u3x_atom(u3h(d));
+    sep = u3x_atom(u3t(d));
+    vat = u3x_atom(u3t(cam));
+    sam = u3h(pay);
+  }
+
+  return u3qc_hew(boq, sep, vat, sam);
+}
diff --git a/vere/pkg/noun/jets/c/lsh.c b/vere/pkg/noun/jets/c/lsh.c
new file mode 100644
index 0000000..09a97e6
--- /dev/null
+++ b/vere/pkg/noun/jets/c/lsh.c
@@ -0,0 +1,63 @@
+/// @file
+
+#include "jets/k.h"
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+u3_noun
+u3qc_lsh(u3_atom a,
+         u3_atom b,
+         u3_atom c)
+{
+  if ( !_(u3a_is_cat(a)) || (a >= 32) ) {
+    return u3m_bail(c3__fail);
+  }
+  else if ( !_(u3a_is_cat(b)) ) {
+    return u3m_bail(c3__fail);
+  }
+  else {
+    c3_g a_g   = a;
+    c3_w b_w   = b;
+    c3_w len_w = u3r_met(a_g, c);
+
+    if ( 0 == len_w ) {
+      return 0;
+    }
+    else if ( (b_w + len_w) < len_w ) {
+      return u3m_bail(c3__exit);
+    }
+    else {
+      u3i_slab sab_u;
+      u3i_slab_init(&sab_u, a_g, (b_w + len_w));
+
+      u3r_chop(a_g, 0, len_w, b_w, sab_u.buf_w, c);
+
+      return u3i_slab_mint(&sab_u);
+    }
+  }
+}
+
+u3_noun
+u3wc_lsh(u3_noun cor)
+{
+  u3_atom bloq, step;
+  u3_noun a, b;
+  u3x_mean(cor, u3x_sam_2, &a,
+                u3x_sam_3, &b, 0);
+  u3x_bite(a, &bloq, &step);
+
+  return u3qc_lsh(bloq, step, u3x_atom(b));
+}
+
+u3_noun
+u3kc_lsh(u3_noun a,
+         u3_noun b,
+         u3_noun c)
+{
+  u3_noun d = u3qc_lsh(a, b, c);
+
+  u3z(a); u3z(b); u3z(c);
+  return d;
+}
diff --git a/vere/pkg/noun/jets/c/mas.c b/vere/pkg/noun/jets/c/mas.c
new file mode 100644
index 0000000..b0be6e1
--- /dev/null
+++ b/vere/pkg/noun/jets/c/mas.c
@@ -0,0 +1,48 @@
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+u3_noun
+u3qc_mas(u3_atom a)
+{
+  c3_w b_w;
+
+  if ( c3y == u3a_is_cat(a) ) {
+    b_w = c3_bits_word(a);
+
+    if ( 2 > b_w ) {
+      return u3m_bail(c3__exit);
+    }
+    else {
+      a  &= ~((c3_w)1 << (b_w - 1));
+      a  |=  ((c3_w)1 << (b_w - 2));
+      return a;
+    }
+  }
+  else {
+    b_w = u3r_met(0, a);
+
+    if ( 64 > b_w ) {
+      c3_d a_d = u3r_chub(0, a);
+      a_d  &= ~((c3_d)1 << (b_w - 1));
+      a_d  |=  ((c3_d)1 << (b_w - 2));
+      return u3i_chub(a_d);
+    }
+    else {
+      u3i_slab sab_u;
+      u3i_slab_from(&sab_u, a, 0, b_w - 1);
+
+      b_w -= 2;
+      sab_u.buf_w[(b_w >> 5)] |= ((c3_w)1 << (b_w & 31));
+
+      return u3i_slab_mint(&sab_u);
+    }
+  }
+}
+
+u3_noun
+u3wc_mas(u3_noun cor)
+{
+  return u3qc_mas(u3x_atom(u3x_at(u3x_sam, cor)));
+}
diff --git a/vere/pkg/noun/jets/c/met.c b/vere/pkg/noun/jets/c/met.c
new file mode 100644
index 0000000..5f3a6a6
--- /dev/null
+++ b/vere/pkg/noun/jets/c/met.c
@@ -0,0 +1,42 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+
+  u3_noun
+  u3qc_met(u3_atom a,
+           u3_atom b)
+  {
+    if ( 0 == b ) {
+      return 0;
+    }
+    else if ( !_(u3a_is_cat(a)) || (a >= 32) ) {
+      return u3m_bail(c3__fail);;
+    }
+    else {
+      c3_w met_w = u3r_met(a, b);
+
+      if ( !_(u3a_is_cat(met_w)) ) {
+        return u3i_words(1, &met_w);
+      }
+      else return met_w;
+    }
+  }
+  u3_noun
+  u3wc_met(u3_noun cor)
+  {
+    u3_noun a, b;
+
+    if ( (c3n == u3r_mean(cor, u3x_sam_2, &a, u3x_sam_3, &b, 0)) ||
+         (c3n == u3ud(b)) ||
+         (c3n == u3ud(a) && 0 != b) )
+    {
+      return u3m_bail(c3__exit);
+    } else {
+      return u3qc_met(a, b);
+    }
+  }
+
diff --git a/vere/pkg/noun/jets/c/mix.c b/vere/pkg/noun/jets/c/mix.c
new file mode 100644
index 0000000..b497c3f
--- /dev/null
+++ b/vere/pkg/noun/jets/c/mix.c
@@ -0,0 +1,56 @@
+/// @file
+
+#include "jets/k.h"
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+
+  u3_noun
+  u3qc_mix(u3_atom a,
+           u3_atom b)
+  {
+    c3_w lna_w = u3r_met(5, a);
+    c3_w lnb_w = u3r_met(5, b);
+
+    if ( (lna_w == 0) && (lnb_w == 0) ) {
+      return 0;
+    }
+    else {
+      c3_w     len_w = c3_max(lna_w, lnb_w);
+      c3_w       i_w;
+      u3i_slab sab_u;
+      u3i_slab_from(&sab_u, a, 5, len_w);
+
+      //  XX use u3r_chop for XOR?
+      //
+      for ( i_w = 0; i_w < lnb_w; i_w++ ) {
+        sab_u.buf_w[i_w] ^= u3r_word(i_w, b);
+      }
+
+      return u3i_slab_mint(&sab_u);
+    }
+  }
+  u3_noun
+  u3wc_mix(u3_noun cor)
+  {
+    u3_noun a, b;
+
+    if ( (c3n == u3r_mean(cor, u3x_sam_2, &a, u3x_sam_3, &b, 0)) ||
+         (c3n == u3ud(a)) ||
+         (c3n == u3ud(b)) )
+    {
+      return u3m_bail(c3__exit);
+    } else {
+      return u3qc_mix(a, b);
+    }
+  }
+  u3_noun
+  u3kc_mix(u3_atom a,
+           u3_atom b)
+  {
+    u3_noun res = u3qc_mix(a, b);
+    u3z(a); u3z(b);
+    return res;
+  }
diff --git a/vere/pkg/noun/jets/c/mor.c b/vere/pkg/noun/jets/c/mor.c
new file mode 100644
index 0000000..97ba141
--- /dev/null
+++ b/vere/pkg/noun/jets/c/mor.c
@@ -0,0 +1,31 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+
+  u3_noun
+  u3qc_mor(u3_noun a,
+           u3_noun b)
+  {
+    c3_w c_w = u3r_mug(u3r_mug(a));
+    c3_w d_w = u3r_mug(u3r_mug(b));
+
+    if ( c_w == d_w ) {
+      return u3qc_dor(a, b);
+    }
+    else return (c_w < d_w) ? c3y : c3n;
+  }
+  u3_noun
+  u3wc_mor(u3_noun cor)
+  {
+    u3_noun a, b;
+
+    if ( (c3n == u3r_mean(cor, u3x_sam_2, &a, u3x_sam_3, &b, 0)) ) {
+      return u3m_bail(c3__exit);
+    } else {
+      return u3qc_mor(a, b);
+    }
+  }
diff --git a/vere/pkg/noun/jets/c/mug.c b/vere/pkg/noun/jets/c/mug.c
new file mode 100644
index 0000000..ec6e483
--- /dev/null
+++ b/vere/pkg/noun/jets/c/mug.c
@@ -0,0 +1,19 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+
+  u3_noun
+  u3wc_mug(u3_noun cor)
+  {
+    u3_noun sam;
+
+    if ( u3_none == (sam = u3r_at(u3x_sam, cor)) ) {
+      return u3m_bail(c3__exit);
+    } else {
+      return u3r_mug(sam);
+    }
+  }
diff --git a/vere/pkg/noun/jets/c/muk.c b/vere/pkg/noun/jets/c/muk.c
new file mode 100644
index 0000000..0846ed7
--- /dev/null
+++ b/vere/pkg/noun/jets/c/muk.c
@@ -0,0 +1,76 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+#include "murmur3.h"
+
+u3_noun
+u3qc_muk(u3_atom sed,
+         u3_atom len,
+         u3_atom key)
+{
+  if ( c3n == u3a_is_cat(len) ) {
+    return u3m_bail(c3__fail);
+  }
+  else {
+    c3_w len_w = (c3_w)len;
+    c3_w key_w = u3r_met(3, key);
+
+    //  NB: this condition is implicit in the pad subtraction
+    //
+    if ( key_w > len_w ) {
+      return u3m_bail(c3__exit);
+    }
+    else {
+      c3_w  sed_w = u3r_word(0, sed);
+      c3_o  loc_o = c3n;
+      c3_y* key_y = 0;
+      c3_w  out_w;
+
+      //  if we're hashing more bytes than we have, allocate and copy
+      //  to ensure trailing null bytes
+      //
+      if ( len_w > key_w ) {
+        loc_o = c3y;
+        key_y = u3a_calloc(sizeof(c3_y), len_w);
+        u3r_bytes(0, len_w, key_y, key);
+      }
+      else if ( len_w > 0 ) {
+        //  XX assumes little-endian
+        //
+        key_y = ( c3y == u3a_is_cat(key) )
+                ? (c3_y*)&key
+                : (c3_y*)((u3a_atom*)u3a_to_ptr(key))->buf_w;
+      }
+
+      MurmurHash3_x86_32(key_y, len_w, sed_w, &out_w);
+
+      if ( c3y == loc_o ) {
+        u3a_free(key_y);
+      }
+
+      return u3i_words(1, &out_w);
+    }
+  }
+}
+
+u3_noun
+u3wc_muk(u3_noun cor)
+{
+  u3_noun sed, len, key;
+  u3x_mean(cor, u3x_sam_2, &sed,
+                u3x_sam_6, &len,
+                u3x_sam_7, &key, 0);
+
+  if (  (c3n == u3ud(sed))
+     || (c3n == u3ud(len))
+     || (c3n == u3ud(key)) )
+  {
+    return u3m_bail(c3__exit);
+  }
+  else {
+    return u3qc_muk(sed, len, key);
+  }
+}
diff --git a/vere/pkg/noun/jets/c/peg.c b/vere/pkg/noun/jets/c/peg.c
new file mode 100644
index 0000000..a700752
--- /dev/null
+++ b/vere/pkg/noun/jets/c/peg.c
@@ -0,0 +1,66 @@
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+u3_noun
+u3qc_peg(u3_atom a, u3_atom b)
+{
+  if ( (0 == a) || (0 == b) ) {
+    return u3m_bail(c3__exit);
+  }
+  else if ( 1 == b ) {
+    return u3k(a);
+  }
+
+  c3_d a_d, b_d;
+  c3_w c_w;
+
+  if ( (c3y == u3a_is_cat(a)) && (c3y == u3a_is_cat(b)) ) {
+    c_w = c3_bits_word(b) - 1;
+    a_d = a;
+    b_d = b;
+  }
+  else {
+    c3_w d_w = u3r_met(0, a);
+    c3_d e_d;
+
+    c_w = u3r_met(0, b) - 1;
+    e_d = (c3_d)c_w + d_w;
+
+    if ( 64 <= e_d ) {
+      u3i_slab sab_u;
+      u3i_slab_init(&sab_u, 0, e_d);
+
+      u3r_chop(0, 0, c_w,   0, sab_u.buf_w, b);
+      u3r_chop(0, 0, d_w, c_w, sab_u.buf_w, a);
+
+      return u3i_slab_moot(&sab_u);
+    }
+
+    a_d = u3r_chub(0, a);
+    b_d = u3r_chub(0, b);
+  }
+
+  b_d  &= ((c3_d)1 << c_w) - 1;
+  a_d <<= c_w;
+  a_d  ^= b_d;
+
+  return u3i_chub(a_d);
+}
+
+u3_noun
+u3wc_peg(u3_noun cor)
+{
+  u3_noun a, b;
+
+  if ( (c3n == u3r_mean(cor, u3x_sam_2, &a, u3x_sam_3, &b, 0)) ||
+       (c3n == u3ud(b)) ||
+       (c3n == u3ud(a) && b != 1) )
+  {
+    return u3m_bail(c3__exit);
+  }
+  else {
+    return u3qc_peg(a, b);
+  }
+}
diff --git a/vere/pkg/noun/jets/c/po.c b/vere/pkg/noun/jets/c/po.c
new file mode 100644
index 0000000..2fe8858
--- /dev/null
+++ b/vere/pkg/noun/jets/c/po.c
@@ -0,0 +1,1427 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+u3_noun
+u3_po_find_prefix(c3_y one, c3_y two, c3_y three) {
+  switch (one) {
+    case 'b': switch (two) {
+      case 'a': switch (three)  {
+        case 'c': return u3nc(0, 238);
+        case 'l': return u3nc(0, 107);
+        case 'n': return u3nc(0, 92);
+        case 'r': return u3nc(0, 183);
+        case 't': return u3nc(0, 172);
+        default: return 0;
+      }
+      case 'i': switch (three)  {
+        case 'c': return u3nc(0, 56);
+        case 'd': return u3nc(0, 106);
+        case 'l': return u3nc(0, 144);
+        case 'n': return u3nc(0, 2);
+        case 's': return u3nc(0, 60);
+        case 't': return u3nc(0, 182);
+        default: return 0;
+      }
+      case 'o': switch (three)  {
+        case 'l': return u3nc(0, 45);
+        case 'n': return u3nc(0, 244);
+        case 'r': return u3nc(0, 188);
+        case 's': return u3nc(0, 171);
+        case 't': return u3nc(0, 98);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'd': switch (two) {
+      case 'a': switch (three)  {
+        case 'b': return u3nc(0, 181);
+        case 'c': return u3nc(0, 117);
+        case 'l': return u3nc(0, 37);
+        case 'n': return u3nc(0, 234);
+        case 'p': return u3nc(0, 66);
+        case 'r': return u3nc(0, 23);
+        case 's': return u3nc(0, 61);
+        case 't': return u3nc(0, 215);
+        case 'v': return u3nc(0, 105);
+        default: return 0;
+      }
+      case 'i': switch (three)  {
+        case 'b': return u3nc(0, 179);
+        case 'f': return u3nc(0, 57);
+        case 'g': return u3nc(0, 193);
+        case 'l': return u3nc(0, 49);
+        case 'n': return u3nc(0, 217);
+        case 'r': return u3nc(0, 11);
+        case 's': return u3nc(0, 129);
+        case 'v': return u3nc(0, 116);
+        default: return 0;
+      }
+      case 'o': switch (three)  {
+        case 'c': return u3nc(0, 146);
+        case 'l': return u3nc(0, 102);
+        case 'n': return u3nc(0, 233);
+        case 'p': return u3nc(0, 18);
+        case 'r': return u3nc(0, 24);
+        case 's': return u3nc(0, 187);
+        case 't': return u3nc(0, 47);
+        case 'v': return u3nc(0, 236);
+        case 'z': return u3nc(0, 0);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'f': switch (two) {
+      case 'a': switch (three)  {
+        case 'b': return u3nc(0, 120);
+        case 'd': return u3nc(0, 206);
+        case 'l': return u3nc(0, 152);
+        case 'm': return u3nc(0, 214);
+        case 'n': return u3nc(0, 158);
+        case 's': return u3nc(0, 195);
+        default: return 0;
+      }
+      case 'i': switch (three)  {
+        case 'd': return u3nc(0, 8);
+        case 'g': return u3nc(0, 138);
+        case 'l': return u3nc(0, 194);
+        case 'n': return u3nc(0, 90);
+        case 'p': return u3nc(0, 255);
+        case 'r': return u3nc(0, 169);
+        case 't': return u3nc(0, 226);
+        default: return 0;
+      }
+      case 'o': switch (three)  {
+        case 'd': return u3nc(0, 247);
+        case 'g': return u3nc(0, 20);
+        case 'l': return u3nc(0, 27);
+        case 'n': return u3nc(0, 91);
+        case 'p': return u3nc(0, 213);
+        case 'r': return u3nc(0, 50);
+        case 's': return u3nc(0, 46);
+        case 't': return u3nc(0, 221);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'h': switch (two) {
+      case 'a': switch (three)  {
+        case 'b': return u3nc(0, 209);
+        case 'c': return u3nc(0, 174);
+        case 'd': return u3nc(0, 145);
+        case 'l': return u3nc(0, 203);
+        case 'n': return u3nc(0, 41);
+        case 'p': return u3nc(0, 156);
+        case 'r': return u3nc(0, 198);
+        case 's': return u3nc(0, 170);
+        case 't': return u3nc(0, 218);
+        case 'v': return u3nc(0, 176);
+        default: return 0;
+      }
+      case 'i': switch (three)  {
+        case 'd': return u3nc(0, 7);
+        case 'l': return u3nc(0, 190);
+        case 'n': return u3nc(0, 200);
+        default: return 0;
+      }
+      case 'o': switch (three)  {
+        case 'b': return u3nc(0, 197);
+        case 'c': return u3nc(0, 223);
+        case 'd': return u3nc(0, 26);
+        case 'l': return u3nc(0, 32);
+        case 'p': return u3nc(0, 22);
+        case 's': return u3nc(0, 180);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'l': switch (two) {
+      case 'a': switch (three)  {
+        case 'b': return u3nc(0, 161);
+        case 'c': return u3nc(0, 34);
+        case 'd': return u3nc(0, 235);
+        case 'g': return u3nc(0, 205);
+        case 'n': return u3nc(0, 232);
+        case 'p': return u3nc(0, 240);
+        case 'r': return u3nc(0, 225);
+        case 's': return u3nc(0, 128);
+        case 't': return u3nc(0, 134);
+        case 'v': return u3nc(0, 252);
+        default: return 0;
+      }
+      case 'i': switch (three)  {
+        case 'b': return u3nc(0, 39);
+        case 'd': return u3nc(0, 21);
+        case 'g': return u3nc(0, 111);
+        case 'n': return u3nc(0, 178);
+        case 's': return u3nc(0, 9);
+        case 't': return u3nc(0, 5);
+        case 'v': return u3nc(0, 36);
+        default: return 0;
+      }
+      case 'o': switch (three)  {
+        case 'c': return u3nc(0, 69);
+        case 'd': return u3nc(0, 186);
+        case 'm': return u3nc(0, 166);
+        case 'n': return u3nc(0, 135);
+        case 'p': return u3nc(0, 63);
+        case 'r': return u3nc(0, 25);
+        case 's': return u3nc(0, 48);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'm': switch (two) {
+      case 'a': switch (three)  {
+        case 'c': return u3nc(0, 191);
+        case 'g': return u3nc(0, 103);
+        case 'l': return u3nc(0, 110);
+        case 'p': return u3nc(0, 130);
+        case 'r': return u3nc(0, 1);
+        case 's': return u3nc(0, 202);
+        case 't': return u3nc(0, 253);
+        default: return 0;
+      }
+      case 'i': switch (three)  {
+        case 'c': return u3nc(0, 157);
+        case 'd': return u3nc(0, 62);
+        case 'g': return u3nc(0, 199);
+        case 'l': return u3nc(0, 212);
+        case 'n': return u3nc(0, 79);
+        case 'p': return u3nc(0, 254);
+        case 'r': return u3nc(0, 31);
+        case 's': return u3nc(0, 126);
+        case 't': return u3nc(0, 196);
+        default: return 0;
+      }
+      case 'o': switch (three)  {
+        case 'c': return u3nc(0, 148);
+        case 'd': return u3nc(0, 19);
+        case 'g': return u3nc(0, 162);
+        case 'l': return u3nc(0, 67);
+        case 'n': return u3nc(0, 122);
+        case 'p': return u3nc(0, 208);
+        case 'r': return u3nc(0, 93);
+        case 's': return u3nc(0, 231);
+        case 't': return u3nc(0, 82);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'n': switch (two) {
+      case 'a': switch (three)  {
+        case 'c': return u3nc(0, 219);
+        case 'l': return u3nc(0, 230);
+        case 'm': return u3nc(0, 243);
+        case 'p': return u3nc(0, 87);
+        case 'r': return u3nc(0, 65);
+        case 't': return u3nc(0, 77);
+        case 'v': return u3nc(0, 137);
+        default: return 0;
+      }
+      case 'i': switch (three)  {
+        case 'b': return u3nc(0, 140);
+        case 'd': return u3nc(0, 72);
+        case 'l': return u3nc(0, 210);
+        case 'm': return u3nc(0, 224);
+        case 's': return u3nc(0, 124);
+        default: return 0;
+      }
+      case 'o': switch (three)  {
+        case 'c': return u3nc(0, 250);
+        case 'd': return u3nc(0, 136);
+        case 'l': return u3nc(0, 216);
+        case 'm': return u3nc(0, 139);
+        case 'p': return u3nc(0, 88);
+        case 'r': return u3nc(0, 97);
+        case 's': return u3nc(0, 211);
+        case 'v': return u3nc(0, 70);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'p': switch (two) {
+      case 'a': switch (three)  {
+        case 'c': return u3nc(0, 149);
+        case 'd': return u3nc(0, 114);
+        case 'g': return u3nc(0, 141);
+        case 'l': return u3nc(0, 127);
+        case 'n': return u3nc(0, 78);
+        case 'r': return u3nc(0, 185);
+        case 's': return u3nc(0, 33);
+        case 't': return u3nc(0, 159);
+        default: return 0;
+      }
+      case 'i': switch (three)  {
+        case 'c': return u3nc(0, 104);
+        case 'd': return u3nc(0, 43);
+        case 'l': return u3nc(0, 51);
+        case 'n': return u3nc(0, 165);
+        case 't': return u3nc(0, 242);
+        default: return 0;
+      }
+      case 'o': switch (three)  {
+        case 'c': return u3nc(0, 173);
+        case 'd': return u3nc(0, 81);
+        case 'l': return u3nc(0, 239);
+        case 'n': return u3nc(0, 248);
+        case 's': return u3nc(0, 86);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'r': switch (two) {
+      case 'a': switch (three)  {
+        case 'b': return u3nc(0, 131);
+        case 'c': return u3nc(0, 184);
+        case 'd': return u3nc(0, 201);
+        case 'g': return u3nc(0, 204);
+        case 'l': return u3nc(0, 143);
+        case 'm': return u3nc(0, 52);
+        case 'n': return u3nc(0, 123);
+        case 'p': return u3nc(0, 228);
+        case 'v': return u3nc(0, 150);
+        default: return 0;
+      }
+      case 'i': switch (three)  {
+        case 'b': return u3nc(0, 222);
+        case 'c': return u3nc(0, 167);
+        case 'd': return u3nc(0, 147);
+        case 'g': return u3nc(0, 16);
+        case 'l': return u3nc(0, 64);
+        case 'n': return u3nc(0, 28);
+        case 'p': return u3nc(0, 151);
+        case 's': return u3nc(0, 220);
+        case 't': return u3nc(0, 80);
+        case 'v': return u3nc(0, 237);
+        default: return 0;
+      }
+      case 'o': switch (three)  {
+        case 'c': return u3nc(0, 58);
+        case 'l': return u3nc(0, 133);
+        case 'n': return u3nc(0, 96);
+        case 'p': return u3nc(0, 75);
+        case 's': return u3nc(0, 245);
+        case 'v': return u3nc(0, 35);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 's': switch (two) {
+      case 'a': switch (three)  {
+        case 'b': return u3nc(0, 13);
+        case 'l': return u3nc(0, 115);
+        case 'm': return u3nc(0, 4);
+        case 'n': return u3nc(0, 68);
+        case 'p': return u3nc(0, 177);
+        case 'r': return u3nc(0, 229);
+        case 't': return u3nc(0, 38);
+        case 'v': return u3nc(0, 85);
+        default: return 0;
+      }
+      case 'i': switch (three)  {
+        case 'b': return u3nc(0, 15);
+        case 'c': return u3nc(0, 74);
+        case 'd': return u3nc(0, 119);
+        case 'g': return u3nc(0, 6);
+        case 'l': return u3nc(0, 30);
+        case 'm': return u3nc(0, 163);
+        case 'p': return u3nc(0, 95);
+        case 't': return u3nc(0, 71);
+        case 'v': return u3nc(0, 112);
+        default: return 0;
+      }
+      case 'o': switch (three)  {
+        case 'c': return u3nc(0, 100);
+        case 'g': return u3nc(0, 10);
+        case 'l': return u3nc(0, 17);
+        case 'm': return u3nc(0, 89);
+        case 'n': return u3nc(0, 164);
+        case 'p': return u3nc(0, 142);
+        case 'r': return u3nc(0, 251);
+        case 'v': return u3nc(0, 249);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 't': switch (two) {
+      case 'a': switch (three)  {
+        case 'b': return u3nc(0, 40);
+        case 'c': return u3nc(0, 160);
+        case 'd': return u3nc(0, 55);
+        case 'g': return u3nc(0, 113);
+        case 'l': return u3nc(0, 241);
+        case 'm': return u3nc(0, 83);
+        case 'n': return u3nc(0, 118);
+        case 'p': return u3nc(0, 168);
+        case 'r': return u3nc(0, 121);
+        case 's': return u3nc(0, 109);
+        default: return 0;
+      }
+      case 'i': switch (three)  {
+        case 'c': return u3nc(0, 42);
+        case 'd': return u3nc(0, 175);
+        case 'l': return u3nc(0, 154);
+        case 'm': return u3nc(0, 108);
+        case 'n': return u3nc(0, 155);
+        case 'p': return u3nc(0, 73);
+        case 'r': return u3nc(0, 53);
+        default: return 0;
+      }
+      case 'o': switch (three)  {
+        case 'b': return u3nc(0, 132);
+        case 'c': return u3nc(0, 189);
+        case 'd': return u3nc(0, 153);
+        case 'g': return u3nc(0, 29);
+        case 'l': return u3nc(0, 84);
+        case 'm': return u3nc(0, 192);
+        case 'n': return u3nc(0, 246);
+        case 'p': return u3nc(0, 207);
+        case 'r': return u3nc(0, 44);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'w': switch (two) {
+      case 'a': switch (three)  {
+        case 'c': return u3nc(0, 12);
+        case 'l': return u3nc(0, 227);
+        case 'n': return u3nc(0, 3);
+        case 't': return u3nc(0, 101);
+        default: return 0;
+      }
+      case 'i': switch (three)  {
+        case 'c': return u3nc(0, 99);
+        case 'd': return u3nc(0, 59);
+        case 'n': return u3nc(0, 54);
+        case 's': return u3nc(0, 14);
+        case 't': return u3nc(0, 76);
+        default: return 0;
+      }
+      case 'o': switch (three)  {
+        case 'l': return u3nc(0, 125);
+        case 'r': return u3nc(0, 94);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    default: return 0;
+  }
+}
+
+void
+u3_po_to_prefix(u3_noun id, c3_y* a, c3_y* b, c3_y* c)
+{
+  switch (id) {
+    case 0: *a = 'd'; *b = 'o'; *c = 'z'; break;
+    case 1: *a = 'm'; *b = 'a'; *c = 'r'; break;
+    case 2: *a = 'b'; *b = 'i'; *c = 'n'; break;
+    case 3: *a = 'w'; *b = 'a'; *c = 'n'; break;
+    case 4: *a = 's'; *b = 'a'; *c = 'm'; break;
+    case 5: *a = 'l'; *b = 'i'; *c = 't'; break;
+    case 6: *a = 's'; *b = 'i'; *c = 'g'; break;
+    case 7: *a = 'h'; *b = 'i'; *c = 'd'; break;
+    case 8: *a = 'f'; *b = 'i'; *c = 'd'; break;
+    case 9: *a = 'l'; *b = 'i'; *c = 's'; break;
+    case 10: *a = 's'; *b = 'o'; *c = 'g'; break;
+    case 11: *a = 'd'; *b = 'i'; *c = 'r'; break;
+    case 12: *a = 'w'; *b = 'a'; *c = 'c'; break;
+    case 13: *a = 's'; *b = 'a'; *c = 'b'; break;
+    case 14: *a = 'w'; *b = 'i'; *c = 's'; break;
+    case 15: *a = 's'; *b = 'i'; *c = 'b'; break;
+    case 16: *a = 'r'; *b = 'i'; *c = 'g'; break;
+    case 17: *a = 's'; *b = 'o'; *c = 'l'; break;
+    case 18: *a = 'd'; *b = 'o'; *c = 'p'; break;
+    case 19: *a = 'm'; *b = 'o'; *c = 'd'; break;
+    case 20: *a = 'f'; *b = 'o'; *c = 'g'; break;
+    case 21: *a = 'l'; *b = 'i'; *c = 'd'; break;
+    case 22: *a = 'h'; *b = 'o'; *c = 'p'; break;
+    case 23: *a = 'd'; *b = 'a'; *c = 'r'; break;
+    case 24: *a = 'd'; *b = 'o'; *c = 'r'; break;
+    case 25: *a = 'l'; *b = 'o'; *c = 'r'; break;
+    case 26: *a = 'h'; *b = 'o'; *c = 'd'; break;
+    case 27: *a = 'f'; *b = 'o'; *c = 'l'; break;
+    case 28: *a = 'r'; *b = 'i'; *c = 'n'; break;
+    case 29: *a = 't'; *b = 'o'; *c = 'g'; break;
+    case 30: *a = 's'; *b = 'i'; *c = 'l'; break;
+    case 31: *a = 'm'; *b = 'i'; *c = 'r'; break;
+    case 32: *a = 'h'; *b = 'o'; *c = 'l'; break;
+    case 33: *a = 'p'; *b = 'a'; *c = 's'; break;
+    case 34: *a = 'l'; *b = 'a'; *c = 'c'; break;
+    case 35: *a = 'r'; *b = 'o'; *c = 'v'; break;
+    case 36: *a = 'l'; *b = 'i'; *c = 'v'; break;
+    case 37: *a = 'd'; *b = 'a'; *c = 'l'; break;
+    case 38: *a = 's'; *b = 'a'; *c = 't'; break;
+    case 39: *a = 'l'; *b = 'i'; *c = 'b'; break;
+    case 40: *a = 't'; *b = 'a'; *c = 'b'; break;
+    case 41: *a = 'h'; *b = 'a'; *c = 'n'; break;
+    case 42: *a = 't'; *b = 'i'; *c = 'c'; break;
+    case 43: *a = 'p'; *b = 'i'; *c = 'd'; break;
+    case 44: *a = 't'; *b = 'o'; *c = 'r'; break;
+    case 45: *a = 'b'; *b = 'o'; *c = 'l'; break;
+    case 46: *a = 'f'; *b = 'o'; *c = 's'; break;
+    case 47: *a = 'd'; *b = 'o'; *c = 't'; break;
+    case 48: *a = 'l'; *b = 'o'; *c = 's'; break;
+    case 49: *a = 'd'; *b = 'i'; *c = 'l'; break;
+    case 50: *a = 'f'; *b = 'o'; *c = 'r'; break;
+    case 51: *a = 'p'; *b = 'i'; *c = 'l'; break;
+    case 52: *a = 'r'; *b = 'a'; *c = 'm'; break;
+    case 53: *a = 't'; *b = 'i'; *c = 'r'; break;
+    case 54: *a = 'w'; *b = 'i'; *c = 'n'; break;
+    case 55: *a = 't'; *b = 'a'; *c = 'd'; break;
+    case 56: *a = 'b'; *b = 'i'; *c = 'c'; break;
+    case 57: *a = 'd'; *b = 'i'; *c = 'f'; break;
+    case 58: *a = 'r'; *b = 'o'; *c = 'c'; break;
+    case 59: *a = 'w'; *b = 'i'; *c = 'd'; break;
+    case 60: *a = 'b'; *b = 'i'; *c = 's'; break;
+    case 61: *a = 'd'; *b = 'a'; *c = 's'; break;
+    case 62: *a = 'm'; *b = 'i'; *c = 'd'; break;
+    case 63: *a = 'l'; *b = 'o'; *c = 'p'; break;
+    case 64: *a = 'r'; *b = 'i'; *c = 'l'; break;
+    case 65: *a = 'n'; *b = 'a'; *c = 'r'; break;
+    case 66: *a = 'd'; *b = 'a'; *c = 'p'; break;
+    case 67: *a = 'm'; *b = 'o'; *c = 'l'; break;
+    case 68: *a = 's'; *b = 'a'; *c = 'n'; break;
+    case 69: *a = 'l'; *b = 'o'; *c = 'c'; break;
+    case 70: *a = 'n'; *b = 'o'; *c = 'v'; break;
+    case 71: *a = 's'; *b = 'i'; *c = 't'; break;
+    case 72: *a = 'n'; *b = 'i'; *c = 'd'; break;
+    case 73: *a = 't'; *b = 'i'; *c = 'p'; break;
+    case 74: *a = 's'; *b = 'i'; *c = 'c'; break;
+    case 75: *a = 'r'; *b = 'o'; *c = 'p'; break;
+    case 76: *a = 'w'; *b = 'i'; *c = 't'; break;
+    case 77: *a = 'n'; *b = 'a'; *c = 't'; break;
+    case 78: *a = 'p'; *b = 'a'; *c = 'n'; break;
+    case 79: *a = 'm'; *b = 'i'; *c = 'n'; break;
+    case 80: *a = 'r'; *b = 'i'; *c = 't'; break;
+    case 81: *a = 'p'; *b = 'o'; *c = 'd'; break;
+    case 82: *a = 'm'; *b = 'o'; *c = 't'; break;
+    case 83: *a = 't'; *b = 'a'; *c = 'm'; break;
+    case 84: *a = 't'; *b = 'o'; *c = 'l'; break;
+    case 85: *a = 's'; *b = 'a'; *c = 'v'; break;
+    case 86: *a = 'p'; *b = 'o'; *c = 's'; break;
+    case 87: *a = 'n'; *b = 'a'; *c = 'p'; break;
+    case 88: *a = 'n'; *b = 'o'; *c = 'p'; break;
+    case 89: *a = 's'; *b = 'o'; *c = 'm'; break;
+    case 90: *a = 'f'; *b = 'i'; *c = 'n'; break;
+    case 91: *a = 'f'; *b = 'o'; *c = 'n'; break;
+    case 92: *a = 'b'; *b = 'a'; *c = 'n'; break;
+    case 93: *a = 'm'; *b = 'o'; *c = 'r'; break;
+    case 94: *a = 'w'; *b = 'o'; *c = 'r'; break;
+    case 95: *a = 's'; *b = 'i'; *c = 'p'; break;
+    case 96: *a = 'r'; *b = 'o'; *c = 'n'; break;
+    case 97: *a = 'n'; *b = 'o'; *c = 'r'; break;
+    case 98: *a = 'b'; *b = 'o'; *c = 't'; break;
+    case 99: *a = 'w'; *b = 'i'; *c = 'c'; break;
+    case 100: *a = 's'; *b = 'o'; *c = 'c'; break;
+    case 101: *a = 'w'; *b = 'a'; *c = 't'; break;
+    case 102: *a = 'd'; *b = 'o'; *c = 'l'; break;
+    case 103: *a = 'm'; *b = 'a'; *c = 'g'; break;
+    case 104: *a = 'p'; *b = 'i'; *c = 'c'; break;
+    case 105: *a = 'd'; *b = 'a'; *c = 'v'; break;
+    case 106: *a = 'b'; *b = 'i'; *c = 'd'; break;
+    case 107: *a = 'b'; *b = 'a'; *c = 'l'; break;
+    case 108: *a = 't'; *b = 'i'; *c = 'm'; break;
+    case 109: *a = 't'; *b = 'a'; *c = 's'; break;
+    case 110: *a = 'm'; *b = 'a'; *c = 'l'; break;
+    case 111: *a = 'l'; *b = 'i'; *c = 'g'; break;
+    case 112: *a = 's'; *b = 'i'; *c = 'v'; break;
+    case 113: *a = 't'; *b = 'a'; *c = 'g'; break;
+    case 114: *a = 'p'; *b = 'a'; *c = 'd'; break;
+    case 115: *a = 's'; *b = 'a'; *c = 'l'; break;
+    case 116: *a = 'd'; *b = 'i'; *c = 'v'; break;
+    case 117: *a = 'd'; *b = 'a'; *c = 'c'; break;
+    case 118: *a = 't'; *b = 'a'; *c = 'n'; break;
+    case 119: *a = 's'; *b = 'i'; *c = 'd'; break;
+    case 120: *a = 'f'; *b = 'a'; *c = 'b'; break;
+    case 121: *a = 't'; *b = 'a'; *c = 'r'; break;
+    case 122: *a = 'm'; *b = 'o'; *c = 'n'; break;
+    case 123: *a = 'r'; *b = 'a'; *c = 'n'; break;
+    case 124: *a = 'n'; *b = 'i'; *c = 's'; break;
+    case 125: *a = 'w'; *b = 'o'; *c = 'l'; break;
+    case 126: *a = 'm'; *b = 'i'; *c = 's'; break;
+    case 127: *a = 'p'; *b = 'a'; *c = 'l'; break;
+    case 128: *a = 'l'; *b = 'a'; *c = 's'; break;
+    case 129: *a = 'd'; *b = 'i'; *c = 's'; break;
+    case 130: *a = 'm'; *b = 'a'; *c = 'p'; break;
+    case 131: *a = 'r'; *b = 'a'; *c = 'b'; break;
+    case 132: *a = 't'; *b = 'o'; *c = 'b'; break;
+    case 133: *a = 'r'; *b = 'o'; *c = 'l'; break;
+    case 134: *a = 'l'; *b = 'a'; *c = 't'; break;
+    case 135: *a = 'l'; *b = 'o'; *c = 'n'; break;
+    case 136: *a = 'n'; *b = 'o'; *c = 'd'; break;
+    case 137: *a = 'n'; *b = 'a'; *c = 'v'; break;
+    case 138: *a = 'f'; *b = 'i'; *c = 'g'; break;
+    case 139: *a = 'n'; *b = 'o'; *c = 'm'; break;
+    case 140: *a = 'n'; *b = 'i'; *c = 'b'; break;
+    case 141: *a = 'p'; *b = 'a'; *c = 'g'; break;
+    case 142: *a = 's'; *b = 'o'; *c = 'p'; break;
+    case 143: *a = 'r'; *b = 'a'; *c = 'l'; break;
+    case 144: *a = 'b'; *b = 'i'; *c = 'l'; break;
+    case 145: *a = 'h'; *b = 'a'; *c = 'd'; break;
+    case 146: *a = 'd'; *b = 'o'; *c = 'c'; break;
+    case 147: *a = 'r'; *b = 'i'; *c = 'd'; break;
+    case 148: *a = 'm'; *b = 'o'; *c = 'c'; break;
+    case 149: *a = 'p'; *b = 'a'; *c = 'c'; break;
+    case 150: *a = 'r'; *b = 'a'; *c = 'v'; break;
+    case 151: *a = 'r'; *b = 'i'; *c = 'p'; break;
+    case 152: *a = 'f'; *b = 'a'; *c = 'l'; break;
+    case 153: *a = 't'; *b = 'o'; *c = 'd'; break;
+    case 154: *a = 't'; *b = 'i'; *c = 'l'; break;
+    case 155: *a = 't'; *b = 'i'; *c = 'n'; break;
+    case 156: *a = 'h'; *b = 'a'; *c = 'p'; break;
+    case 157: *a = 'm'; *b = 'i'; *c = 'c'; break;
+    case 158: *a = 'f'; *b = 'a'; *c = 'n'; break;
+    case 159: *a = 'p'; *b = 'a'; *c = 't'; break;
+    case 160: *a = 't'; *b = 'a'; *c = 'c'; break;
+    case 161: *a = 'l'; *b = 'a'; *c = 'b'; break;
+    case 162: *a = 'm'; *b = 'o'; *c = 'g'; break;
+    case 163: *a = 's'; *b = 'i'; *c = 'm'; break;
+    case 164: *a = 's'; *b = 'o'; *c = 'n'; break;
+    case 165: *a = 'p'; *b = 'i'; *c = 'n'; break;
+    case 166: *a = 'l'; *b = 'o'; *c = 'm'; break;
+    case 167: *a = 'r'; *b = 'i'; *c = 'c'; break;
+    case 168: *a = 't'; *b = 'a'; *c = 'p'; break;
+    case 169: *a = 'f'; *b = 'i'; *c = 'r'; break;
+    case 170: *a = 'h'; *b = 'a'; *c = 's'; break;
+    case 171: *a = 'b'; *b = 'o'; *c = 's'; break;
+    case 172: *a = 'b'; *b = 'a'; *c = 't'; break;
+    case 173: *a = 'p'; *b = 'o'; *c = 'c'; break;
+    case 174: *a = 'h'; *b = 'a'; *c = 'c'; break;
+    case 175: *a = 't'; *b = 'i'; *c = 'd'; break;
+    case 176: *a = 'h'; *b = 'a'; *c = 'v'; break;
+    case 177: *a = 's'; *b = 'a'; *c = 'p'; break;
+    case 178: *a = 'l'; *b = 'i'; *c = 'n'; break;
+    case 179: *a = 'd'; *b = 'i'; *c = 'b'; break;
+    case 180: *a = 'h'; *b = 'o'; *c = 's'; break;
+    case 181: *a = 'd'; *b = 'a'; *c = 'b'; break;
+    case 182: *a = 'b'; *b = 'i'; *c = 't'; break;
+    case 183: *a = 'b'; *b = 'a'; *c = 'r'; break;
+    case 184: *a = 'r'; *b = 'a'; *c = 'c'; break;
+    case 185: *a = 'p'; *b = 'a'; *c = 'r'; break;
+    case 186: *a = 'l'; *b = 'o'; *c = 'd'; break;
+    case 187: *a = 'd'; *b = 'o'; *c = 's'; break;
+    case 188: *a = 'b'; *b = 'o'; *c = 'r'; break;
+    case 189: *a = 't'; *b = 'o'; *c = 'c'; break;
+    case 190: *a = 'h'; *b = 'i'; *c = 'l'; break;
+    case 191: *a = 'm'; *b = 'a'; *c = 'c'; break;
+    case 192: *a = 't'; *b = 'o'; *c = 'm'; break;
+    case 193: *a = 'd'; *b = 'i'; *c = 'g'; break;
+    case 194: *a = 'f'; *b = 'i'; *c = 'l'; break;
+    case 195: *a = 'f'; *b = 'a'; *c = 's'; break;
+    case 196: *a = 'm'; *b = 'i'; *c = 't'; break;
+    case 197: *a = 'h'; *b = 'o'; *c = 'b'; break;
+    case 198: *a = 'h'; *b = 'a'; *c = 'r'; break;
+    case 199: *a = 'm'; *b = 'i'; *c = 'g'; break;
+    case 200: *a = 'h'; *b = 'i'; *c = 'n'; break;
+    case 201: *a = 'r'; *b = 'a'; *c = 'd'; break;
+    case 202: *a = 'm'; *b = 'a'; *c = 's'; break;
+    case 203: *a = 'h'; *b = 'a'; *c = 'l'; break;
+    case 204: *a = 'r'; *b = 'a'; *c = 'g'; break;
+    case 205: *a = 'l'; *b = 'a'; *c = 'g'; break;
+    case 206: *a = 'f'; *b = 'a'; *c = 'd'; break;
+    case 207: *a = 't'; *b = 'o'; *c = 'p'; break;
+    case 208: *a = 'm'; *b = 'o'; *c = 'p'; break;
+    case 209: *a = 'h'; *b = 'a'; *c = 'b'; break;
+    case 210: *a = 'n'; *b = 'i'; *c = 'l'; break;
+    case 211: *a = 'n'; *b = 'o'; *c = 's'; break;
+    case 212: *a = 'm'; *b = 'i'; *c = 'l'; break;
+    case 213: *a = 'f'; *b = 'o'; *c = 'p'; break;
+    case 214: *a = 'f'; *b = 'a'; *c = 'm'; break;
+    case 215: *a = 'd'; *b = 'a'; *c = 't'; break;
+    case 216: *a = 'n'; *b = 'o'; *c = 'l'; break;
+    case 217: *a = 'd'; *b = 'i'; *c = 'n'; break;
+    case 218: *a = 'h'; *b = 'a'; *c = 't'; break;
+    case 219: *a = 'n'; *b = 'a'; *c = 'c'; break;
+    case 220: *a = 'r'; *b = 'i'; *c = 's'; break;
+    case 221: *a = 'f'; *b = 'o'; *c = 't'; break;
+    case 222: *a = 'r'; *b = 'i'; *c = 'b'; break;
+    case 223: *a = 'h'; *b = 'o'; *c = 'c'; break;
+    case 224: *a = 'n'; *b = 'i'; *c = 'm'; break;
+    case 225: *a = 'l'; *b = 'a'; *c = 'r'; break;
+    case 226: *a = 'f'; *b = 'i'; *c = 't'; break;
+    case 227: *a = 'w'; *b = 'a'; *c = 'l'; break;
+    case 228: *a = 'r'; *b = 'a'; *c = 'p'; break;
+    case 229: *a = 's'; *b = 'a'; *c = 'r'; break;
+    case 230: *a = 'n'; *b = 'a'; *c = 'l'; break;
+    case 231: *a = 'm'; *b = 'o'; *c = 's'; break;
+    case 232: *a = 'l'; *b = 'a'; *c = 'n'; break;
+    case 233: *a = 'd'; *b = 'o'; *c = 'n'; break;
+    case 234: *a = 'd'; *b = 'a'; *c = 'n'; break;
+    case 235: *a = 'l'; *b = 'a'; *c = 'd'; break;
+    case 236: *a = 'd'; *b = 'o'; *c = 'v'; break;
+    case 237: *a = 'r'; *b = 'i'; *c = 'v'; break;
+    case 238: *a = 'b'; *b = 'a'; *c = 'c'; break;
+    case 239: *a = 'p'; *b = 'o'; *c = 'l'; break;
+    case 240: *a = 'l'; *b = 'a'; *c = 'p'; break;
+    case 241: *a = 't'; *b = 'a'; *c = 'l'; break;
+    case 242: *a = 'p'; *b = 'i'; *c = 't'; break;
+    case 243: *a = 'n'; *b = 'a'; *c = 'm'; break;
+    case 244: *a = 'b'; *b = 'o'; *c = 'n'; break;
+    case 245: *a = 'r'; *b = 'o'; *c = 's'; break;
+    case 246: *a = 't'; *b = 'o'; *c = 'n'; break;
+    case 247: *a = 'f'; *b = 'o'; *c = 'd'; break;
+    case 248: *a = 'p'; *b = 'o'; *c = 'n'; break;
+    case 249: *a = 's'; *b = 'o'; *c = 'v'; break;
+    case 250: *a = 'n'; *b = 'o'; *c = 'c'; break;
+    case 251: *a = 's'; *b = 'o'; *c = 'r'; break;
+    case 252: *a = 'l'; *b = 'a'; *c = 'v'; break;
+    case 253: *a = 'm'; *b = 'a'; *c = 't'; break;
+    case 254: *a = 'm'; *b = 'i'; *c = 'p'; break;
+    case 255: *a = 'f'; *b = 'i'; *c = 'p'; break;
+    default: u3m_bail(c3__exit);
+  }
+}
+
+u3_noun
+u3_po_find_suffix(c3_y one, c3_y two, c3_y three) {
+  switch (one) {
+    case 'b': switch (two) {
+      case 'e': switch (three)  {
+        case 'c': return u3nc(0, 238);
+        case 'l': return u3nc(0, 107);
+        case 'n': return u3nc(0, 92);
+        case 'p': return u3nc(0, 183);
+        case 'r': return u3nc(0, 172);
+        case 's': return u3nc(0, 56);
+        case 't': return u3nc(0, 106);
+        case 'x': return u3nc(0, 144);
+        default: return 0;
+      }
+      case 'u': switch (three)  {
+        case 'd': return u3nc(0, 2);
+        case 'r': return u3nc(0, 60);
+        case 's': return u3nc(0, 182);
+        default: return 0;
+      }
+      case 'y': switch (three)  {
+        case 'l': return u3nc(0, 176);
+        case 'n': return u3nc(0, 45);
+        case 'r': return u3nc(0, 244);
+        case 't': return u3nc(0, 188);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'd': switch (two) {
+      case 'e': switch (three)  {
+        case 'b': return u3nc(0, 171);
+        case 'c': return u3nc(0, 98);
+        case 'f': return u3nc(0, 181);
+        case 'g': return u3nc(0, 117);
+        case 'l': return u3nc(0, 37);
+        case 'm': return u3nc(0, 234);
+        case 'n': return u3nc(0, 66);
+        case 'p': return u3nc(0, 23);
+        case 'r': return u3nc(0, 61);
+        case 's': return u3nc(0, 215);
+        case 't': return u3nc(0, 105);
+        case 'v': return u3nc(0, 179);
+        case 'x': return u3nc(0, 57);
+        default: return 0;
+      }
+      case 'u': switch (three)  {
+        case 'c': return u3nc(0, 193);
+        case 'l': return u3nc(0, 49);
+        case 'n': return u3nc(0, 217);
+        case 'r': return u3nc(0, 11);
+        case 's': return u3nc(0, 129);
+        case 't': return u3nc(0, 116);
+        case 'x': return u3nc(0, 146);
+        default: return 0;
+      }
+      case 'y': switch (three)  {
+        case 'l': return u3nc(0, 102);
+        case 'n': return u3nc(0, 233);
+        case 'r': return u3nc(0, 18);
+        case 's': return u3nc(0, 24);
+        case 't': return u3nc(0, 187);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'f': switch (two) {
+      case 'e': switch (three)  {
+        case 'b': return u3nc(0, 47);
+        case 'd': return u3nc(0, 236);
+        case 'l': return u3nc(0, 120);
+        case 'n': return u3nc(0, 206);
+        case 'p': return u3nc(0, 152);
+        case 'r': return u3nc(0, 158);
+        case 's': return u3nc(0, 255);
+        case 't': return u3nc(0, 214);
+        case 'x': return u3nc(0, 195);
+        default: return 0;
+      }
+      case 'u': switch (three)  {
+        case 'l': return u3nc(0, 8);
+        case 'n': return u3nc(0, 138);
+        case 'r': return u3nc(0, 194);
+        case 's': return u3nc(0, 90);
+        default: return 0;
+      }
+      case 'y': switch (three)  {
+        case 'l': return u3nc(0, 169);
+        case 'n': return u3nc(0, 226);
+        case 'r': return u3nc(0, 247);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'h': switch (two) {
+      case 'e': switch (three)  {
+        case 'b': return u3nc(0, 20);
+        case 'c': return u3nc(0, 27);
+        case 'p': return u3nc(0, 91);
+        case 's': return u3nc(0, 213);
+        case 't': return u3nc(0, 50);
+        case 'x': return u3nc(0, 46);
+        default: return 0;
+      }
+      case 'u': switch (three)  {
+        case 'l': return u3nc(0, 221);
+        case 's': return u3nc(0, 209);
+        case 't': return u3nc(0, 174);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'l': switch (two) {
+      case 'e': switch (three)  {
+        case 'b': return u3nc(0, 145);
+        case 'c': return u3nc(0, 203);
+        case 'd': return u3nc(0, 41);
+        case 'g': return u3nc(0, 156);
+        case 'n': return u3nc(0, 198);
+        case 'p': return u3nc(0, 170);
+        case 'r': return u3nc(0, 218);
+        case 't': return u3nc(0, 7);
+        case 'v': return u3nc(0, 190);
+        case 'x': return u3nc(0, 200);
+        default: return 0;
+      }
+      case 'u': switch (three)  {
+        case 'c': return u3nc(0, 197);
+        case 'd': return u3nc(0, 223);
+        case 'g': return u3nc(0, 26);
+        case 'n': return u3nc(0, 32);
+        case 'p': return u3nc(0, 22);
+        case 'r': return u3nc(0, 180);
+        case 's': return u3nc(0, 161);
+        case 't': return u3nc(0, 34);
+        case 'x': return u3nc(0, 235);
+        default: return 0;
+      }
+      case 'y': switch (three)  {
+        case 'd': return u3nc(0, 205);
+        case 'n': return u3nc(0, 232);
+        case 'r': return u3nc(0, 240);
+        case 's': return u3nc(0, 225);
+        case 't': return u3nc(0, 128);
+        case 'x': return u3nc(0, 134);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'm': switch (two) {
+      case 'e': switch (three)  {
+        case 'b': return u3nc(0, 114);
+        case 'c': return u3nc(0, 141);
+        case 'd': return u3nc(0, 127);
+        case 'g': return u3nc(0, 78);
+        case 'l': return u3nc(0, 185);
+        case 'p': return u3nc(0, 33);
+        case 'r': return u3nc(0, 159);
+        case 's': return u3nc(0, 104);
+        case 't': return u3nc(0, 43);
+        case 'v': return u3nc(0, 51);
+        case 'x': return u3nc(0, 165);
+        default: return 0;
+      }
+      case 'u': switch (three)  {
+        case 'd': return u3nc(0, 242);
+        case 'g': return u3nc(0, 173);
+        case 'l': return u3nc(0, 81);
+        case 'n': return u3nc(0, 239);
+        case 'r': return u3nc(0, 248);
+        case 's': return u3nc(0, 93);
+        case 't': return u3nc(0, 86);
+        default: return 0;
+      }
+      case 'y': switch (three)  {
+        case 'l': return u3nc(0, 191);
+        case 'n': return u3nc(0, 103);
+        case 'r': return u3nc(0, 110);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'n': switch (two) {
+      case 'e': switch (three)  {
+        case 'b': return u3nc(0, 130);
+        case 'c': return u3nc(0, 1);
+        case 'd': return u3nc(0, 202);
+        case 'l': return u3nc(0, 253);
+        case 'm': return u3nc(0, 157);
+        case 'p': return u3nc(0, 62);
+        case 'r': return u3nc(0, 199);
+        case 's': return u3nc(0, 212);
+        case 't': return u3nc(0, 79);
+        case 'v': return u3nc(0, 254);
+        case 'x': return u3nc(0, 31);
+        default: return 0;
+      }
+      case 'u': switch (three)  {
+        case 'b': return u3nc(0, 126);
+        case 'l': return u3nc(0, 196);
+        case 'm': return u3nc(0, 148);
+        case 'p': return u3nc(0, 19);
+        case 's': return u3nc(0, 162);
+        case 't': return u3nc(0, 67);
+        case 'x': return u3nc(0, 122);
+        default: return 0;
+      }
+      case 'y': switch (three)  {
+        case 'd': return u3nc(0, 208);
+        case 'l': return u3nc(0, 231);
+        case 'm': return u3nc(0, 82);
+        case 'r': return u3nc(0, 219);
+        case 's': return u3nc(0, 230);
+        case 't': return u3nc(0, 243);
+        case 'x': return u3nc(0, 87);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'p': switch (two) {
+      case 'e': switch (three)  {
+        case 'c': return u3nc(0, 252);
+        case 'd': return u3nc(0, 39);
+        case 'g': return u3nc(0, 21);
+        case 'l': return u3nc(0, 111);
+        case 'm': return u3nc(0, 178);
+        case 'n': return u3nc(0, 9);
+        case 'r': return u3nc(0, 5);
+        case 's': return u3nc(0, 36);
+        case 't': return u3nc(0, 69);
+        case 'x': return u3nc(0, 186);
+        default: return 0;
+      }
+      case 'u': switch (three)  {
+        case 'b': return u3nc(0, 166);
+        case 'n': return u3nc(0, 135);
+        case 'r': return u3nc(0, 63);
+        case 't': return u3nc(0, 25);
+        default: return 0;
+      }
+      case 'y': switch (three)  {
+        case 'l': return u3nc(0, 48);
+        case 'x': return u3nc(0, 149);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'r': switch (two) {
+      case 'e': switch (three)  {
+        case 'b': return u3nc(0, 65);
+        case 'c': return u3nc(0, 77);
+        case 'd': return u3nc(0, 137);
+        case 'f': return u3nc(0, 140);
+        case 'g': return u3nc(0, 72);
+        case 'l': return u3nc(0, 210);
+        case 'm': return u3nc(0, 224);
+        case 'n': return u3nc(0, 124);
+        case 'p': return u3nc(0, 250);
+        case 's': return u3nc(0, 136);
+        case 't': return u3nc(0, 216);
+        case 'v': return u3nc(0, 139);
+        case 'x': return u3nc(0, 88);
+        default: return 0;
+      }
+      case 'u': switch (three)  {
+        case 'c': return u3nc(0, 97);
+        case 'd': return u3nc(0, 211);
+        case 'l': return u3nc(0, 70);
+        case 'm': return u3nc(0, 131);
+        case 'n': return u3nc(0, 184);
+        case 'p': return u3nc(0, 201);
+        case 's': return u3nc(0, 143);
+        case 't': return u3nc(0, 52);
+        case 'x': return u3nc(0, 123);
+        default: return 0;
+      }
+      case 'y': switch (three)  {
+        case 'c': return u3nc(0, 228);
+        case 'd': return u3nc(0, 204);
+        case 'g': return u3nc(0, 150);
+        case 'l': return u3nc(0, 222);
+        case 'm': return u3nc(0, 167);
+        case 'n': return u3nc(0, 147);
+        case 'p': return u3nc(0, 16);
+        case 's': return u3nc(0, 64);
+        case 't': return u3nc(0, 28);
+        case 'x': return u3nc(0, 151);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 's': switch (two) {
+      case 'e': switch (three)  {
+        case 'b': return u3nc(0, 220);
+        case 'c': return u3nc(0, 80);
+        case 'd': return u3nc(0, 237);
+        case 'f': return u3nc(0, 58);
+        case 'g': return u3nc(0, 133);
+        case 'l': return u3nc(0, 96);
+        case 'm': return u3nc(0, 75);
+        case 'n': return u3nc(0, 245);
+        case 'p': return u3nc(0, 35);
+        case 'r': return u3nc(0, 13);
+        case 't': return u3nc(0, 115);
+        case 'v': return u3nc(0, 4);
+        default: return 0;
+      }
+      case 'u': switch (three)  {
+        case 'b': return u3nc(0, 68);
+        case 'd': return u3nc(0, 177);
+        case 'g': return u3nc(0, 229);
+        case 'l': return u3nc(0, 38);
+        case 'm': return u3nc(0, 85);
+        case 'n': return u3nc(0, 15);
+        case 'p': return u3nc(0, 74);
+        case 'r': return u3nc(0, 119);
+        case 't': return u3nc(0, 6);
+        default: return 0;
+      }
+      case 'y': switch (three)  {
+        case 'd': return u3nc(0, 30);
+        case 'l': return u3nc(0, 163);
+        case 'm': return u3nc(0, 95);
+        case 'n': return u3nc(0, 71);
+        case 'p': return u3nc(0, 112);
+        case 'r': return u3nc(0, 100);
+        case 't': return u3nc(0, 10);
+        case 'x': return u3nc(0, 17);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 't': switch (two) {
+      case 'e': switch (three)  {
+        case 'b': return u3nc(0, 89);
+        case 'c': return u3nc(0, 164);
+        case 'd': return u3nc(0, 142);
+        case 'g': return u3nc(0, 251);
+        case 'l': return u3nc(0, 249);
+        case 'm': return u3nc(0, 40);
+        case 'n': return u3nc(0, 160);
+        case 'p': return u3nc(0, 55);
+        case 'r': return u3nc(0, 113);
+        case 's': return u3nc(0, 241);
+        case 'v': return u3nc(0, 83);
+        case 'x': return u3nc(0, 118);
+        default: return 0;
+      }
+      case 'u': switch (three)  {
+        case 'c': return u3nc(0, 168);
+        case 'd': return u3nc(0, 121);
+        case 'g': return u3nc(0, 109);
+        case 'l': return u3nc(0, 42);
+        case 'n': return u3nc(0, 175);
+        case 's': return u3nc(0, 154);
+        case 'x': return u3nc(0, 108);
+        default: return 0;
+      }
+      case 'y': switch (three)  {
+        case 'c': return u3nc(0, 155);
+        case 'd': return u3nc(0, 73);
+        case 'l': return u3nc(0, 53);
+        case 'n': return u3nc(0, 132);
+        case 'p': return u3nc(0, 189);
+        case 'r': return u3nc(0, 153);
+        case 'v': return u3nc(0, 29);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'w': switch (two) {
+      case 'e': switch (three)  {
+        case 'b': return u3nc(0, 84);
+        case 'd': return u3nc(0, 192);
+        case 'g': return u3nc(0, 246);
+        case 'l': return u3nc(0, 207);
+        case 'n': return u3nc(0, 44);
+        case 'p': return u3nc(0, 12);
+        case 'r': return u3nc(0, 227);
+        case 's': return u3nc(0, 3);
+        case 't': return u3nc(0, 101);
+        case 'x': return u3nc(0, 99);
+        default: return 0;
+      }
+      case 'y': switch (three)  {
+        case 'c': return u3nc(0, 59);
+        case 'd': return u3nc(0, 54);
+        case 'l': return u3nc(0, 14);
+        case 'n': return u3nc(0, 76);
+        case 't': return u3nc(0, 125);
+        case 'x': return u3nc(0, 94);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    case 'z': switch (two) {
+      case 'o': switch (three)  {
+        case 'd': return u3nc(0, 0);
+        default: return 0;
+      }
+      default: return 0;
+    }
+    default: return 0;
+  }
+}
+
+void
+u3_po_to_suffix(u3_noun id, c3_y* a, c3_y* b, c3_y* c)
+{
+  switch (id) {
+    case 0: *a = 'z'; *b = 'o'; *c = 'd'; break;
+    case 1: *a = 'n'; *b = 'e'; *c = 'c'; break;
+    case 2: *a = 'b'; *b = 'u'; *c = 'd'; break;
+    case 3: *a = 'w'; *b = 'e'; *c = 's'; break;
+    case 4: *a = 's'; *b = 'e'; *c = 'v'; break;
+    case 5: *a = 'p'; *b = 'e'; *c = 'r'; break;
+    case 6: *a = 's'; *b = 'u'; *c = 't'; break;
+    case 7: *a = 'l'; *b = 'e'; *c = 't'; break;
+    case 8: *a = 'f'; *b = 'u'; *c = 'l'; break;
+    case 9: *a = 'p'; *b = 'e'; *c = 'n'; break;
+    case 10: *a = 's'; *b = 'y'; *c = 't'; break;
+    case 11: *a = 'd'; *b = 'u'; *c = 'r'; break;
+    case 12: *a = 'w'; *b = 'e'; *c = 'p'; break;
+    case 13: *a = 's'; *b = 'e'; *c = 'r'; break;
+    case 14: *a = 'w'; *b = 'y'; *c = 'l'; break;
+    case 15: *a = 's'; *b = 'u'; *c = 'n'; break;
+    case 16: *a = 'r'; *b = 'y'; *c = 'p'; break;
+    case 17: *a = 's'; *b = 'y'; *c = 'x'; break;
+    case 18: *a = 'd'; *b = 'y'; *c = 'r'; break;
+    case 19: *a = 'n'; *b = 'u'; *c = 'p'; break;
+    case 20: *a = 'h'; *b = 'e'; *c = 'b'; break;
+    case 21: *a = 'p'; *b = 'e'; *c = 'g'; break;
+    case 22: *a = 'l'; *b = 'u'; *c = 'p'; break;
+    case 23: *a = 'd'; *b = 'e'; *c = 'p'; break;
+    case 24: *a = 'd'; *b = 'y'; *c = 's'; break;
+    case 25: *a = 'p'; *b = 'u'; *c = 't'; break;
+    case 26: *a = 'l'; *b = 'u'; *c = 'g'; break;
+    case 27: *a = 'h'; *b = 'e'; *c = 'c'; break;
+    case 28: *a = 'r'; *b = 'y'; *c = 't'; break;
+    case 29: *a = 't'; *b = 'y'; *c = 'v'; break;
+    case 30: *a = 's'; *b = 'y'; *c = 'd'; break;
+    case 31: *a = 'n'; *b = 'e'; *c = 'x'; break;
+    case 32: *a = 'l'; *b = 'u'; *c = 'n'; break;
+    case 33: *a = 'm'; *b = 'e'; *c = 'p'; break;
+    case 34: *a = 'l'; *b = 'u'; *c = 't'; break;
+    case 35: *a = 's'; *b = 'e'; *c = 'p'; break;
+    case 36: *a = 'p'; *b = 'e'; *c = 's'; break;
+    case 37: *a = 'd'; *b = 'e'; *c = 'l'; break;
+    case 38: *a = 's'; *b = 'u'; *c = 'l'; break;
+    case 39: *a = 'p'; *b = 'e'; *c = 'd'; break;
+    case 40: *a = 't'; *b = 'e'; *c = 'm'; break;
+    case 41: *a = 'l'; *b = 'e'; *c = 'd'; break;
+    case 42: *a = 't'; *b = 'u'; *c = 'l'; break;
+    case 43: *a = 'm'; *b = 'e'; *c = 't'; break;
+    case 44: *a = 'w'; *b = 'e'; *c = 'n'; break;
+    case 45: *a = 'b'; *b = 'y'; *c = 'n'; break;
+    case 46: *a = 'h'; *b = 'e'; *c = 'x'; break;
+    case 47: *a = 'f'; *b = 'e'; *c = 'b'; break;
+    case 48: *a = 'p'; *b = 'y'; *c = 'l'; break;
+    case 49: *a = 'd'; *b = 'u'; *c = 'l'; break;
+    case 50: *a = 'h'; *b = 'e'; *c = 't'; break;
+    case 51: *a = 'm'; *b = 'e'; *c = 'v'; break;
+    case 52: *a = 'r'; *b = 'u'; *c = 't'; break;
+    case 53: *a = 't'; *b = 'y'; *c = 'l'; break;
+    case 54: *a = 'w'; *b = 'y'; *c = 'd'; break;
+    case 55: *a = 't'; *b = 'e'; *c = 'p'; break;
+    case 56: *a = 'b'; *b = 'e'; *c = 's'; break;
+    case 57: *a = 'd'; *b = 'e'; *c = 'x'; break;
+    case 58: *a = 's'; *b = 'e'; *c = 'f'; break;
+    case 59: *a = 'w'; *b = 'y'; *c = 'c'; break;
+    case 60: *a = 'b'; *b = 'u'; *c = 'r'; break;
+    case 61: *a = 'd'; *b = 'e'; *c = 'r'; break;
+    case 62: *a = 'n'; *b = 'e'; *c = 'p'; break;
+    case 63: *a = 'p'; *b = 'u'; *c = 'r'; break;
+    case 64: *a = 'r'; *b = 'y'; *c = 's'; break;
+    case 65: *a = 'r'; *b = 'e'; *c = 'b'; break;
+    case 66: *a = 'd'; *b = 'e'; *c = 'n'; break;
+    case 67: *a = 'n'; *b = 'u'; *c = 't'; break;
+    case 68: *a = 's'; *b = 'u'; *c = 'b'; break;
+    case 69: *a = 'p'; *b = 'e'; *c = 't'; break;
+    case 70: *a = 'r'; *b = 'u'; *c = 'l'; break;
+    case 71: *a = 's'; *b = 'y'; *c = 'n'; break;
+    case 72: *a = 'r'; *b = 'e'; *c = 'g'; break;
+    case 73: *a = 't'; *b = 'y'; *c = 'd'; break;
+    case 74: *a = 's'; *b = 'u'; *c = 'p'; break;
+    case 75: *a = 's'; *b = 'e'; *c = 'm'; break;
+    case 76: *a = 'w'; *b = 'y'; *c = 'n'; break;
+    case 77: *a = 'r'; *b = 'e'; *c = 'c'; break;
+    case 78: *a = 'm'; *b = 'e'; *c = 'g'; break;
+    case 79: *a = 'n'; *b = 'e'; *c = 't'; break;
+    case 80: *a = 's'; *b = 'e'; *c = 'c'; break;
+    case 81: *a = 'm'; *b = 'u'; *c = 'l'; break;
+    case 82: *a = 'n'; *b = 'y'; *c = 'm'; break;
+    case 83: *a = 't'; *b = 'e'; *c = 'v'; break;
+    case 84: *a = 'w'; *b = 'e'; *c = 'b'; break;
+    case 85: *a = 's'; *b = 'u'; *c = 'm'; break;
+    case 86: *a = 'm'; *b = 'u'; *c = 't'; break;
+    case 87: *a = 'n'; *b = 'y'; *c = 'x'; break;
+    case 88: *a = 'r'; *b = 'e'; *c = 'x'; break;
+    case 89: *a = 't'; *b = 'e'; *c = 'b'; break;
+    case 90: *a = 'f'; *b = 'u'; *c = 's'; break;
+    case 91: *a = 'h'; *b = 'e'; *c = 'p'; break;
+    case 92: *a = 'b'; *b = 'e'; *c = 'n'; break;
+    case 93: *a = 'm'; *b = 'u'; *c = 's'; break;
+    case 94: *a = 'w'; *b = 'y'; *c = 'x'; break;
+    case 95: *a = 's'; *b = 'y'; *c = 'm'; break;
+    case 96: *a = 's'; *b = 'e'; *c = 'l'; break;
+    case 97: *a = 'r'; *b = 'u'; *c = 'c'; break;
+    case 98: *a = 'd'; *b = 'e'; *c = 'c'; break;
+    case 99: *a = 'w'; *b = 'e'; *c = 'x'; break;
+    case 100: *a = 's'; *b = 'y'; *c = 'r'; break;
+    case 101: *a = 'w'; *b = 'e'; *c = 't'; break;
+    case 102: *a = 'd'; *b = 'y'; *c = 'l'; break;
+    case 103: *a = 'm'; *b = 'y'; *c = 'n'; break;
+    case 104: *a = 'm'; *b = 'e'; *c = 's'; break;
+    case 105: *a = 'd'; *b = 'e'; *c = 't'; break;
+    case 106: *a = 'b'; *b = 'e'; *c = 't'; break;
+    case 107: *a = 'b'; *b = 'e'; *c = 'l'; break;
+    case 108: *a = 't'; *b = 'u'; *c = 'x'; break;
+    case 109: *a = 't'; *b = 'u'; *c = 'g'; break;
+    case 110: *a = 'm'; *b = 'y'; *c = 'r'; break;
+    case 111: *a = 'p'; *b = 'e'; *c = 'l'; break;
+    case 112: *a = 's'; *b = 'y'; *c = 'p'; break;
+    case 113: *a = 't'; *b = 'e'; *c = 'r'; break;
+    case 114: *a = 'm'; *b = 'e'; *c = 'b'; break;
+    case 115: *a = 's'; *b = 'e'; *c = 't'; break;
+    case 116: *a = 'd'; *b = 'u'; *c = 't'; break;
+    case 117: *a = 'd'; *b = 'e'; *c = 'g'; break;
+    case 118: *a = 't'; *b = 'e'; *c = 'x'; break;
+    case 119: *a = 's'; *b = 'u'; *c = 'r'; break;
+    case 120: *a = 'f'; *b = 'e'; *c = 'l'; break;
+    case 121: *a = 't'; *b = 'u'; *c = 'd'; break;
+    case 122: *a = 'n'; *b = 'u'; *c = 'x'; break;
+    case 123: *a = 'r'; *b = 'u'; *c = 'x'; break;
+    case 124: *a = 'r'; *b = 'e'; *c = 'n'; break;
+    case 125: *a = 'w'; *b = 'y'; *c = 't'; break;
+    case 126: *a = 'n'; *b = 'u'; *c = 'b'; break;
+    case 127: *a = 'm'; *b = 'e'; *c = 'd'; break;
+    case 128: *a = 'l'; *b = 'y'; *c = 't'; break;
+    case 129: *a = 'd'; *b = 'u'; *c = 's'; break;
+    case 130: *a = 'n'; *b = 'e'; *c = 'b'; break;
+    case 131: *a = 'r'; *b = 'u'; *c = 'm'; break;
+    case 132: *a = 't'; *b = 'y'; *c = 'n'; break;
+    case 133: *a = 's'; *b = 'e'; *c = 'g'; break;
+    case 134: *a = 'l'; *b = 'y'; *c = 'x'; break;
+    case 135: *a = 'p'; *b = 'u'; *c = 'n'; break;
+    case 136: *a = 'r'; *b = 'e'; *c = 's'; break;
+    case 137: *a = 'r'; *b = 'e'; *c = 'd'; break;
+    case 138: *a = 'f'; *b = 'u'; *c = 'n'; break;
+    case 139: *a = 'r'; *b = 'e'; *c = 'v'; break;
+    case 140: *a = 'r'; *b = 'e'; *c = 'f'; break;
+    case 141: *a = 'm'; *b = 'e'; *c = 'c'; break;
+    case 142: *a = 't'; *b = 'e'; *c = 'd'; break;
+    case 143: *a = 'r'; *b = 'u'; *c = 's'; break;
+    case 144: *a = 'b'; *b = 'e'; *c = 'x'; break;
+    case 145: *a = 'l'; *b = 'e'; *c = 'b'; break;
+    case 146: *a = 'd'; *b = 'u'; *c = 'x'; break;
+    case 147: *a = 'r'; *b = 'y'; *c = 'n'; break;
+    case 148: *a = 'n'; *b = 'u'; *c = 'm'; break;
+    case 149: *a = 'p'; *b = 'y'; *c = 'x'; break;
+    case 150: *a = 'r'; *b = 'y'; *c = 'g'; break;
+    case 151: *a = 'r'; *b = 'y'; *c = 'x'; break;
+    case 152: *a = 'f'; *b = 'e'; *c = 'p'; break;
+    case 153: *a = 't'; *b = 'y'; *c = 'r'; break;
+    case 154: *a = 't'; *b = 'u'; *c = 's'; break;
+    case 155: *a = 't'; *b = 'y'; *c = 'c'; break;
+    case 156: *a = 'l'; *b = 'e'; *c = 'g'; break;
+    case 157: *a = 'n'; *b = 'e'; *c = 'm'; break;
+    case 158: *a = 'f'; *b = 'e'; *c = 'r'; break;
+    case 159: *a = 'm'; *b = 'e'; *c = 'r'; break;
+    case 160: *a = 't'; *b = 'e'; *c = 'n'; break;
+    case 161: *a = 'l'; *b = 'u'; *c = 's'; break;
+    case 162: *a = 'n'; *b = 'u'; *c = 's'; break;
+    case 163: *a = 's'; *b = 'y'; *c = 'l'; break;
+    case 164: *a = 't'; *b = 'e'; *c = 'c'; break;
+    case 165: *a = 'm'; *b = 'e'; *c = 'x'; break;
+    case 166: *a = 'p'; *b = 'u'; *c = 'b'; break;
+    case 167: *a = 'r'; *b = 'y'; *c = 'm'; break;
+    case 168: *a = 't'; *b = 'u'; *c = 'c'; break;
+    case 169: *a = 'f'; *b = 'y'; *c = 'l'; break;
+    case 170: *a = 'l'; *b = 'e'; *c = 'p'; break;
+    case 171: *a = 'd'; *b = 'e'; *c = 'b'; break;
+    case 172: *a = 'b'; *b = 'e'; *c = 'r'; break;
+    case 173: *a = 'm'; *b = 'u'; *c = 'g'; break;
+    case 174: *a = 'h'; *b = 'u'; *c = 't'; break;
+    case 175: *a = 't'; *b = 'u'; *c = 'n'; break;
+    case 176: *a = 'b'; *b = 'y'; *c = 'l'; break;
+    case 177: *a = 's'; *b = 'u'; *c = 'd'; break;
+    case 178: *a = 'p'; *b = 'e'; *c = 'm'; break;
+    case 179: *a = 'd'; *b = 'e'; *c = 'v'; break;
+    case 180: *a = 'l'; *b = 'u'; *c = 'r'; break;
+    case 181: *a = 'd'; *b = 'e'; *c = 'f'; break;
+    case 182: *a = 'b'; *b = 'u'; *c = 's'; break;
+    case 183: *a = 'b'; *b = 'e'; *c = 'p'; break;
+    case 184: *a = 'r'; *b = 'u'; *c = 'n'; break;
+    case 185: *a = 'm'; *b = 'e'; *c = 'l'; break;
+    case 186: *a = 'p'; *b = 'e'; *c = 'x'; break;
+    case 187: *a = 'd'; *b = 'y'; *c = 't'; break;
+    case 188: *a = 'b'; *b = 'y'; *c = 't'; break;
+    case 189: *a = 't'; *b = 'y'; *c = 'p'; break;
+    case 190: *a = 'l'; *b = 'e'; *c = 'v'; break;
+    case 191: *a = 'm'; *b = 'y'; *c = 'l'; break;
+    case 192: *a = 'w'; *b = 'e'; *c = 'd'; break;
+    case 193: *a = 'd'; *b = 'u'; *c = 'c'; break;
+    case 194: *a = 'f'; *b = 'u'; *c = 'r'; break;
+    case 195: *a = 'f'; *b = 'e'; *c = 'x'; break;
+    case 196: *a = 'n'; *b = 'u'; *c = 'l'; break;
+    case 197: *a = 'l'; *b = 'u'; *c = 'c'; break;
+    case 198: *a = 'l'; *b = 'e'; *c = 'n'; break;
+    case 199: *a = 'n'; *b = 'e'; *c = 'r'; break;
+    case 200: *a = 'l'; *b = 'e'; *c = 'x'; break;
+    case 201: *a = 'r'; *b = 'u'; *c = 'p'; break;
+    case 202: *a = 'n'; *b = 'e'; *c = 'd'; break;
+    case 203: *a = 'l'; *b = 'e'; *c = 'c'; break;
+    case 204: *a = 'r'; *b = 'y'; *c = 'd'; break;
+    case 205: *a = 'l'; *b = 'y'; *c = 'd'; break;
+    case 206: *a = 'f'; *b = 'e'; *c = 'n'; break;
+    case 207: *a = 'w'; *b = 'e'; *c = 'l'; break;
+    case 208: *a = 'n'; *b = 'y'; *c = 'd'; break;
+    case 209: *a = 'h'; *b = 'u'; *c = 's'; break;
+    case 210: *a = 'r'; *b = 'e'; *c = 'l'; break;
+    case 211: *a = 'r'; *b = 'u'; *c = 'd'; break;
+    case 212: *a = 'n'; *b = 'e'; *c = 's'; break;
+    case 213: *a = 'h'; *b = 'e'; *c = 's'; break;
+    case 214: *a = 'f'; *b = 'e'; *c = 't'; break;
+    case 215: *a = 'd'; *b = 'e'; *c = 's'; break;
+    case 216: *a = 'r'; *b = 'e'; *c = 't'; break;
+    case 217: *a = 'd'; *b = 'u'; *c = 'n'; break;
+    case 218: *a = 'l'; *b = 'e'; *c = 'r'; break;
+    case 219: *a = 'n'; *b = 'y'; *c = 'r'; break;
+    case 220: *a = 's'; *b = 'e'; *c = 'b'; break;
+    case 221: *a = 'h'; *b = 'u'; *c = 'l'; break;
+    case 222: *a = 'r'; *b = 'y'; *c = 'l'; break;
+    case 223: *a = 'l'; *b = 'u'; *c = 'd'; break;
+    case 224: *a = 'r'; *b = 'e'; *c = 'm'; break;
+    case 225: *a = 'l'; *b = 'y'; *c = 's'; break;
+    case 226: *a = 'f'; *b = 'y'; *c = 'n'; break;
+    case 227: *a = 'w'; *b = 'e'; *c = 'r'; break;
+    case 228: *a = 'r'; *b = 'y'; *c = 'c'; break;
+    case 229: *a = 's'; *b = 'u'; *c = 'g'; break;
+    case 230: *a = 'n'; *b = 'y'; *c = 's'; break;
+    case 231: *a = 'n'; *b = 'y'; *c = 'l'; break;
+    case 232: *a = 'l'; *b = 'y'; *c = 'n'; break;
+    case 233: *a = 'd'; *b = 'y'; *c = 'n'; break;
+    case 234: *a = 'd'; *b = 'e'; *c = 'm'; break;
+    case 235: *a = 'l'; *b = 'u'; *c = 'x'; break;
+    case 236: *a = 'f'; *b = 'e'; *c = 'd'; break;
+    case 237: *a = 's'; *b = 'e'; *c = 'd'; break;
+    case 238: *a = 'b'; *b = 'e'; *c = 'c'; break;
+    case 239: *a = 'm'; *b = 'u'; *c = 'n'; break;
+    case 240: *a = 'l'; *b = 'y'; *c = 'r'; break;
+    case 241: *a = 't'; *b = 'e'; *c = 's'; break;
+    case 242: *a = 'm'; *b = 'u'; *c = 'd'; break;
+    case 243: *a = 'n'; *b = 'y'; *c = 't'; break;
+    case 244: *a = 'b'; *b = 'y'; *c = 'r'; break;
+    case 245: *a = 's'; *b = 'e'; *c = 'n'; break;
+    case 246: *a = 'w'; *b = 'e'; *c = 'g'; break;
+    case 247: *a = 'f'; *b = 'y'; *c = 'r'; break;
+    case 248: *a = 'm'; *b = 'u'; *c = 'r'; break;
+    case 249: *a = 't'; *b = 'e'; *c = 'l'; break;
+    case 250: *a = 'r'; *b = 'e'; *c = 'p'; break;
+    case 251: *a = 't'; *b = 'e'; *c = 'g'; break;
+    case 252: *a = 'p'; *b = 'e'; *c = 'c'; break;
+    case 253: *a = 'n'; *b = 'e'; *c = 'l'; break;
+    case 254: *a = 'n'; *b = 'e'; *c = 'v'; break;
+    case 255: *a = 'f'; *b = 'e'; *c = 's'; break;
+    default: u3m_bail(c3__exit);
+  }
+}
+
+u3_noun
+u3qc_po_ins(u3_noun a)
+{
+  c3_y byt_y[3];
+  u3r_bytes(0, 3, byt_y, a);
+
+  return u3_po_find_prefix(byt_y[0], byt_y[1], byt_y[2]);
+}
+
+u3_noun
+u3wcp_ins(u3_noun cor)
+{
+  u3_noun a;
+  u3x_mean(cor, u3x_sam, &a, 0);
+
+  if ( c3n == u3ud(a) ) {
+    return u3m_bail(c3__fail);
+  }
+
+  return u3qc_po_ins(a);
+}
+
+u3_noun
+u3qc_po_ind(u3_noun a)
+{
+  c3_y byt_y[3];
+  u3r_bytes(0, 3, byt_y, a);
+
+  return u3_po_find_suffix(byt_y[0], byt_y[1], byt_y[2]);
+}
+
+u3_noun
+u3wcp_ind(u3_noun cor)
+{
+  u3_noun a;
+  u3x_mean(cor, u3x_sam, &a, 0);
+
+  if ( c3n == u3ud(a) ) {
+    return u3m_bail(c3__fail);
+  }
+
+  return u3qc_po_ind(a);
+}
+
+u3_noun
+u3wcp_tos(u3_noun cor)
+{
+  u3_noun a;
+
+  if ( (c3n == u3r_mean(cor, u3x_sam, &a, 0)) ||
+       (c3n == u3ud(a)) ||
+       (a >= 256) )
+  {
+    return u3m_bail(c3__exit);
+  }
+  else {
+    c3_y byt_y[3];
+    u3_po_to_prefix(a, &byt_y[0], &byt_y[1], &byt_y[2]);
+    return (byt_y[0] | (byt_y[1] << 8) | (byt_y[2] << 16));
+  }
+}
+
+u3_noun
+u3wcp_tod(u3_noun cor)
+{
+  u3_noun a;
+
+  if ( (c3n == u3r_mean(cor, u3x_sam, &a, 0)) ||
+       (c3n == u3ud(a)) ||
+       (a >= 256) )
+  {
+    return u3m_bail(c3__exit);
+  } else {
+    c3_y byt_y[3];
+    u3_po_to_suffix(a, &byt_y[0], &byt_y[1], &byt_y[2]);
+    return (byt_y[0] | (byt_y[1] << 8) | (byt_y[2] << 16));
+  }
+}
diff --git a/vere/pkg/noun/jets/c/pow.c b/vere/pkg/noun/jets/c/pow.c
new file mode 100644
index 0000000..8d45fc8
--- /dev/null
+++ b/vere/pkg/noun/jets/c/pow.c
@@ -0,0 +1,38 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+
+  u3_noun
+  u3qc_pow(u3_atom a,
+           u3_atom b)
+  {
+    if ( !_(u3a_is_cat(b)) ) {
+      return u3m_bail(c3__fail);
+    }
+    else {
+      mpz_t a_mp;
+
+      u3r_mp(a_mp, a);
+      mpz_pow_ui(a_mp, a_mp, b);
+
+      return u3i_mp(a_mp);
+    }
+  }
+  u3_noun
+  u3wc_pow(u3_noun cor)
+  {
+    u3_noun a, b;
+
+    if ( (c3n == u3r_mean(cor, u3x_sam_2, &a, u3x_sam_3, &b, 0)) ||
+         (c3n == u3ud(a)) )
+    {
+      return u3m_bail(c3__exit);
+    } else {
+      return u3qc_pow(a, b);
+    }
+  }
+
diff --git a/vere/pkg/noun/jets/c/rap.c b/vere/pkg/noun/jets/c/rap.c
new file mode 100644
index 0000000..4c95693
--- /dev/null
+++ b/vere/pkg/noun/jets/c/rap.c
@@ -0,0 +1,88 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+
+  u3_noun
+  u3qc_rap(u3_atom a,
+           u3_noun b)
+  {
+    if ( !_(u3a_is_cat(a)) || (a >= 32) ) {
+      return u3m_bail(c3__fail);
+    }
+    else {
+      c3_g       a_g = a;
+      c3_w     tot_w = 0;
+      u3i_slab sab_u;
+
+      /* Measure and validate the slab required.
+      */
+      {
+        u3_noun cab = b;
+
+        while ( 1 ) {
+          u3_noun h_cab;
+          c3_w    len_w;
+
+          if ( 0 == cab ) {
+            break;
+          }
+          else if ( c3n == u3du(cab) ) {
+            return u3m_bail(c3__exit);
+          }
+          else if ( c3n == u3ud(h_cab = u3h(cab)) ) {
+            return u3m_bail(c3__exit);
+          }
+          else if ( (tot_w + (len_w = u3r_met(a_g, h_cab))) < tot_w ) {
+            return u3m_bail(c3__fail);
+          }
+          tot_w += len_w;
+          cab = u3t(cab);
+        }
+
+        if ( 0 == tot_w ) {
+          return 0;
+        }
+
+        u3i_slab_init(&sab_u, a_g, tot_w);
+      }
+
+      /* Chop the list atoms in.
+      */
+      {
+        u3_noun cab = b;
+        c3_w  pos_w = 0;
+
+        while ( 0 != cab ) {
+          u3_noun h_cab = u3h(cab);
+          c3_w    len_w = u3r_met(a_g, h_cab);
+
+          u3r_chop(a_g, 0, len_w, pos_w, sab_u.buf_w, h_cab);
+          pos_w += len_w;
+          cab = u3t(cab);
+        }
+      }
+
+      return u3i_slab_mint(&sab_u);
+    }
+  }
+  u3_noun
+  u3wc_rap(u3_noun cor)
+  {
+    u3_noun a, b;
+
+    if ( (c3n == u3r_mean(cor, u3x_sam_2, &a, u3x_sam_3, &b, 0)) ||
+         (c3n == u3ud(a)) )
+    {
+      return u3m_bail(c3__exit);
+    } else {
+      u3_noun pro;
+
+      pro = u3qc_rap(a, b);
+      return pro;
+    }
+  }
+
diff --git a/vere/pkg/noun/jets/c/rep.c b/vere/pkg/noun/jets/c/rep.c
new file mode 100644
index 0000000..914e917
--- /dev/null
+++ b/vere/pkg/noun/jets/c/rep.c
@@ -0,0 +1,199 @@
+/// @file
+
+#include "jets/k.h"
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+/*
+  Get the lowest `n` bits of a word `w` using a bitmask.
+*/
+#define TAKEBITS(n,w) \
+  ((n)==32) ? (w) :   \
+  ((n)==0)  ? 0   :   \
+  ((w) & ((1 << (n)) - 1))
+
+/*
+  Divide, rounding up.
+*/
+#define DIVCEIL(x,y) \
+  (x==0) ? 0 :       \
+  1 + ((x - 1) / y);
+
+static u3_noun
+_bit_rep(u3_atom bits, u3_noun blox)
+{
+  if ( (c3n == u3a_is_cat(bits) || bits==0 || bits>31) ) {
+    return u3m_bail(c3__fail);
+  }
+
+  //
+  //  Calculate input and output size.
+  //
+  c3_w num_blox_w = u3qb_lent(blox);
+  c3_w bit_widt_w = num_blox_w * bits;
+  c3_w wor_widt_w = DIVCEIL(bit_widt_w, 32);
+  u3i_slab  sab_u;
+  u3i_slab_bare(&sab_u, 5, wor_widt_w);
+
+  //
+  //  Fill the atom buffer with bits from each block.
+  //
+  //  Bits are pushed into the `acc_w` register and flushed to the buffer
+  //  once full.
+  //
+  //  acc_w  register
+  //  use_w  number of register bits filled (used)
+  //  cur_w  next buffer word to flush into.
+  //
+  {
+    c3_w acc_w=0, use_w=0, *cur_w=sab_u.buf_w;
+
+#   define FLUSH() *cur_w++=acc_w; acc_w=use_w=0
+#   define SLICE(sz,off,val) TAKEBITS(sz, val) << off
+
+    for (c3_w i=0; i<num_blox_w; i++) {
+      u3_noun blok_n = u3h(blox);
+      blox = u3t(blox);
+
+      if ( c3n == u3a_is_cat(blok_n) ) {
+        return u3m_bail(c3__fail);
+      }
+
+      c3_w blok_w = blok_n;
+
+      for (c3_w rem_in_blok_w=bits; rem_in_blok_w;) {
+        c3_w rem_in_acc_w = 32 - use_w;
+        if (rem_in_blok_w == rem_in_acc_w) {              //  EQ
+          acc_w |= SLICE(rem_in_blok_w, use_w, blok_w);
+          FLUSH();
+          rem_in_blok_w = 0;
+        }
+        else if (rem_in_blok_w < rem_in_acc_w) {          //  LT
+          acc_w |= SLICE(rem_in_blok_w, use_w, blok_w);
+          use_w += rem_in_blok_w;
+          rem_in_blok_w = 0;
+        }
+        else {                                            //  GT
+          acc_w |= SLICE(rem_in_acc_w, use_w, blok_w);
+          rem_in_blok_w -= rem_in_acc_w;
+          blok_w = blok_w >> rem_in_acc_w;
+          FLUSH();
+        }
+      }
+    }
+
+    //
+    //  If the last word isn't fully used, it will still need to be
+    //  flushed.
+    //
+    if (use_w) {
+      FLUSH();
+    }
+  }
+
+  return u3i_slab_mint(&sab_u);
+}
+
+static u3_noun
+_block_rep(u3_atom a,
+           u3_noun b)
+{
+  if ( !_(u3a_is_cat(a)) || (a >= 32) ) {
+    return u3m_bail(c3__fail);
+  }
+  else {
+    c3_g       a_g = a;
+    c3_w     tot_w = 0;
+    u3i_slab sab_u;
+
+    /* Measure and validate the slab required.
+    */
+    {
+      u3_noun cab = b;
+
+      while ( 1 ) {
+        u3_noun h_cab;
+        c3_w    len_w;
+
+        if ( 0 == cab ) {
+          break;
+        }
+        else if ( c3n == u3du(cab) ) {
+          return u3m_bail(c3__exit);
+        }
+        else if ( c3n == u3ud(h_cab = u3h(cab)) ) {
+          return u3m_bail(c3__exit);
+        }
+        else if ( (tot_w + (len_w = u3r_met(a_g, h_cab))) < tot_w ) {
+          return u3m_bail(c3__fail);
+        }
+        tot_w++;
+        cab = u3t(cab);
+      }
+
+      if ( 0 == tot_w ) {
+        return 0;
+      }
+
+      u3i_slab_init(&sab_u, a_g, tot_w);
+    }
+
+    /* Chop the list atoms in.
+    */
+    {
+      u3_noun cab = b;
+      c3_w  pos_w = 0;
+
+      while ( 0 != cab ) {
+        u3_noun h_cab = u3h(cab);
+
+        u3r_chop(a_g, 0, 1, pos_w, sab_u.buf_w, h_cab);
+        pos_w++;
+        cab = u3t(cab);
+      }
+    }
+
+    return u3i_slab_mint(&sab_u);
+  }
+}
+
+u3_noun
+u3qc_rep(u3_atom a,
+         u3_atom b,
+         u3_noun c)
+{
+  if ( 1 == b ) {
+    return _block_rep(a, c);
+  }
+
+  if ( 0 == a ) {
+    return _bit_rep(b, c);
+  }
+
+  u3l_log("rep: stub");
+  return u3_none;
+}
+
+u3_noun
+u3wc_rep(u3_noun cor)
+{
+  u3_atom bloq, step;
+  u3_noun a, b;
+  u3x_mean(cor, u3x_sam_2, &a,
+                u3x_sam_3, &b, 0);
+  u3x_bite(a, &bloq, &step);
+
+  return u3qc_rep(bloq, step, b);
+}
+
+u3_noun
+u3kc_rep(u3_atom a,
+         u3_atom b,
+         u3_noun c)
+{
+  u3_noun res = u3qc_rep(a, b, c);
+  u3z(a); u3z(b); u3z(c);
+  return res;
+}
diff --git a/vere/pkg/noun/jets/c/rev.c b/vere/pkg/noun/jets/c/rev.c
new file mode 100644
index 0000000..1ce74c0
--- /dev/null
+++ b/vere/pkg/noun/jets/c/rev.c
@@ -0,0 +1,51 @@
+/// @file
+
+#include "jets/k.h"
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+
+  u3_noun
+  u3qc_rev(u3_atom boz,
+           u3_atom len,
+           u3_atom dat)
+  {
+    if ( !_(u3a_is_cat(boz)) || (boz >= 32) ||
+         !_(u3a_is_cat(len)) ) {
+      return u3m_bail(c3__fail);
+    }
+
+    dat = u3qc_end(boz, len, dat);
+    c3_w met = u3r_met(boz, dat);
+    return u3kc_lsh(boz, (len - met), u3kc_swp(boz, dat));
+  }
+
+  u3_noun
+  u3wc_rev(u3_noun cor)
+  {
+    u3_noun boz, len, dat;
+
+    if ( (c3n == u3r_mean(cor, u3x_sam_2, &boz,
+                               u3x_sam_6, &len,
+                               u3x_sam_7, &dat, 0)) ||
+         (c3n == u3ud(boz)) ||
+         (c3n == u3ud(len)) ||
+         (c3n == u3ud(dat)) )
+    {
+      return u3m_bail(c3__exit);
+    } else {
+      return u3qc_rev(boz, len, dat);
+    }
+  }
+
+  u3_noun
+  u3kc_rev(u3_atom boz,
+           u3_atom len,
+           u3_atom dat)
+  {
+    u3_noun res = u3qc_rev(boz, len, dat);
+    u3z(boz); u3z(len); u3z(dat);
+    return res;
+  }
diff --git a/vere/pkg/noun/jets/c/rig.c b/vere/pkg/noun/jets/c/rig.c
new file mode 100644
index 0000000..7e5e7b9
--- /dev/null
+++ b/vere/pkg/noun/jets/c/rig.c
@@ -0,0 +1,82 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+c3_d
+u3qc_rig_s(c3_g foq_g,
+           c3_w sep_w,
+           c3_g toq_g)
+{
+  c3_d sep_d = sep_w;
+
+  if ( foq_g >= toq_g ) {
+    return sep_d << (foq_g - toq_g);
+  }
+  else {
+    c3_g dif_g = toq_g - foq_g;
+
+    sep_d += (1 << dif_g) - 1;
+    return sep_d >> dif_g;
+  }
+}
+
+u3_noun
+u3qc_rig(u3_atom foq,
+         u3_atom sep,
+         u3_atom toq)
+{
+  if ( c3y == u3r_sing(foq, toq) ) {
+    return u3k(sep);
+  }
+
+  if (  (c3y == u3a_is_cat(foq)) && (foq < 32)
+     && (c3y == u3a_is_cat(toq)) && (toq < 32)
+     && (c3y == u3a_is_cat(sep)) )
+  {
+    c3_d sep_d = u3qc_rig_s((c3_g)foq, (c3_w)sep, (c3_g)toq);
+    return u3i_chub(sep_d);
+  }
+
+  if ( c3y == u3qa_gth(foq, toq) ) {
+    u3_atom d = u3qa_sub(foq, toq);
+    u3_atom e = u3qc_lsh(0, d, sep);
+    u3z(d);
+    return e;
+  }
+  else {
+    u3_atom d = u3qa_sub(toq, foq);
+    u3_atom e = u3qc_rsh(0, d, sep);
+    u3_atom f = u3qc_end(0, d, sep);
+
+    if ( f ) {
+      e = u3i_vint(e);
+      u3z(f);
+    }
+
+    u3z(d);
+    return e;
+  }
+}
+
+u3_noun
+u3wc_rig(u3_noun cor)
+{
+  u3_atom boq, sep, vat;
+  {
+    u3_noun sam = u3h(u3t(cor));
+    u3_noun bit = u3h(sam);
+
+    if ( c3y == u3a_is_atom(bit) ) {
+      return 0;
+    }
+
+    boq = u3x_atom(u3h(bit));
+    sep = u3x_atom(u3t(bit));
+    vat = u3x_atom(u3t(sam));
+  }
+
+  return u3qc_rig(boq, sep, vat);
+}
diff --git a/vere/pkg/noun/jets/c/rip.c b/vere/pkg/noun/jets/c/rip.c
new file mode 100644
index 0000000..bff23b8
--- /dev/null
+++ b/vere/pkg/noun/jets/c/rip.c
@@ -0,0 +1,192 @@
+/// @file
+
+#include "jets/k.h"
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+/*
+  Get the lowest `n` bits of a word `w` using a bitmask.
+*/
+#define TAKEBITS(n,w) \
+  ((n)==32) ? (w) :   \
+  ((n)==0)  ? 0   :   \
+  ((w) & ((1 << (n)) - 1))
+
+/*
+  Divide, rounding up.
+*/
+#define DIVCEIL(x,y) \
+  (x==0) ? 0 :       \
+  1 + ((x - 1) / y);
+
+/*
+  `ripn` breaks `atom` into a list of blocks, of bit-width `bits`. The
+  resulting list will be least-significant block first.
+
+  XX TODO This only handles cases where the bit-width is <= 32.
+
+  For each block we produce, we need to grab the relevant words inside
+  `atom`, so we first compute their indicies.
+
+  `ins_idx` is the word-index of the least-significant word we
+  care about, and `sig_idx` is the word after that.
+
+  Next we grab those words (`ins_word` and `sig_word`) from the atom
+  using `u3r_word`. Note that `sig_idx` might be out-of-bounds for the
+  underlying array of `atom`, but `u3r_word` returns 0 in that case,
+  which is exatly what we want.
+
+  Now, we need to grab the relevant bits out of both words, and combine
+  them. `bits_rem_in_ins_word` is the number of remaining (insignificant)
+  bits in `ins_word`, `nbits_ins` is the number of bits we want from the
+  less-significant word, and `nbits_sig` from the more-significant one.
+
+  Take the least significant `nbits_sig` bits from `sig_word`, and take
+  the slice we care about from `ins_word`. In order to take that slice,
+  we drop `bits_rem_in_ins_word` insignificant bits, and then take the
+  `nbits_sig` most-significant bits.
+
+  Last, we slice out those bits from the two words, combine them into
+  one word, and cons them onto the front of the result.
+*/
+static u3_noun
+_bit_rip(u3_atom bits, u3_atom atom)
+{
+  if ( !_(u3a_is_cat(bits) || bits==0 || bits>31) ) {
+    return u3m_bail(c3__fail);
+  }
+
+  c3_w bit_width  = u3r_met(0, atom);
+  c3_w num_blocks = DIVCEIL(bit_width, bits);
+
+  u3_noun res = u3_nul;
+
+  for ( c3_w blk = 0; blk < num_blocks; blk++ ) {
+    c3_w next_blk = blk + 1;
+    c3_w blks_rem = num_blocks - next_blk;
+    c3_w bits_rem = blks_rem * bits;
+    c3_w ins_idx  = bits_rem / 32;
+    c3_w sig_idx  = ins_idx + 1;
+
+    c3_w bits_rem_in_ins_word = bits_rem % 32;
+
+    c3_w ins_word  = u3r_word(ins_idx, atom);
+    c3_w sig_word  = u3r_word(sig_idx, atom);
+    c3_w nbits_ins = c3_min(bits, 32 - bits_rem_in_ins_word);
+    c3_w nbits_sig = bits - nbits_ins;
+
+    c3_w ins_word_bits = TAKEBITS(nbits_ins, ins_word >> bits_rem_in_ins_word);
+    c3_w sig_word_bits = TAKEBITS(nbits_sig, sig_word);
+
+    c3_w item = ins_word_bits | (sig_word_bits << nbits_ins);
+
+    res = u3nc(item, res);
+  }
+
+  return res;
+}
+
+static u3_noun
+_block_rip(u3_atom bloq, u3_atom b)
+{
+  if ( !_(u3a_is_cat(bloq)) || (bloq >= 32) ) {
+    return u3m_bail(c3__fail);
+  }
+
+  c3_g bloq_g = bloq;
+
+  /*
+    This is a fast-path for the case where all the resulting blocks will
+    fit in 31-bit direct atoms.
+  */
+  if ( bloq_g < 5 ) {                                   //  produce direct atoms
+    u3_noun acc     = u3_nul;
+
+    c3_w met_w   = u3r_met(bloq_g, b);                  //  num blocks in atom
+    c3_w nbits_w = 1 << bloq_g;                         //  block size in bits
+    c3_w bmask_w = (1 << nbits_w) - 1;                  //  result mask
+
+    for ( c3_w i_w = 0; i_w < met_w; i_w++ ) {          //  `i_w` is block index
+      c3_w nex_w = i_w + 1;                             //  next block
+      c3_w pat_w = met_w - nex_w;                       //  blks left after this
+      c3_w bit_w = pat_w << bloq_g;                     //  bits left after this
+      c3_w wor_w = bit_w >> 5;                          //  wrds left after this
+      c3_w sif_w = bit_w & 31;                          //  bits left in word
+      c3_w src_w = u3r_word(wor_w, b);                  //  find word by index
+      c3_w rip_w = (src_w >> sif_w) & bmask_w;          //  get item from word
+
+      acc = u3nc(rip_w, acc);
+    }
+
+    return acc;
+  }
+
+  u3_noun acc   = u3_nul;
+  c3_w    met_w = u3r_met(bloq_g, b);
+  c3_w    len_w = u3r_met(5, b);
+  c3_g    san_g = (bloq_g - 5);
+  c3_w    san_w = 1 << san_g;
+  c3_w    dif_w = (met_w << san_g) - len_w;
+  c3_w    tub_w = ((dif_w == 0) ? san_w : (san_w - dif_w));
+
+  for ( c3_w i_w = 0; i_w < met_w; i_w++ ) {
+    c3_w     pat_w = (met_w - (i_w + 1));
+    c3_w     wut_w = (pat_w << san_g);
+    c3_w     sap_w = ((0 == i_w) ? tub_w : san_w);
+    c3_w       j_w;
+    u3_atom    rip;
+    u3i_slab sab_u;
+    u3i_slab_bare(&sab_u, 5, sap_w);
+
+    for ( j_w = 0; j_w < sap_w; j_w++ ) {
+      sab_u.buf_w[j_w] = u3r_word(wut_w + j_w, b);
+    }
+
+    rip = u3i_slab_mint(&sab_u);
+    acc = u3nc(rip, acc);
+    len_w -= san_w;
+  }
+
+  return acc;
+}
+
+u3_noun
+u3qc_rip(u3_atom a,
+         u3_atom b,
+         u3_atom c)
+{
+  if ( 1 == b ) {
+    return _block_rip(a, c);
+  }
+
+  if ( 0 == a ) {
+    return _bit_rip(b, c);
+  }
+
+  u3l_log("rip: stub");
+  return u3_none;
+}
+
+u3_noun
+u3wc_rip(u3_noun cor)
+{
+  u3_atom bloq, step;
+  u3_noun a, b;
+  u3x_mean(cor, u3x_sam_2, &a,
+                u3x_sam_3, &b, 0);
+  u3x_bite(a, &bloq, &step);
+
+  return u3qc_rip(bloq, step, u3x_atom(b));
+}
+
+u3_noun
+u3kc_rip(u3_atom a,
+         u3_atom b,
+         u3_atom c)
+{
+  u3_noun pro = u3qc_rip(a, b, c);
+  u3z(a); u3z(b); u3z(c);
+  return pro;
+}
diff --git a/vere/pkg/noun/jets/c/rsh.c b/vere/pkg/noun/jets/c/rsh.c
new file mode 100644
index 0000000..6fc8ddf
--- /dev/null
+++ b/vere/pkg/noun/jets/c/rsh.c
@@ -0,0 +1,60 @@
+/// @file
+
+#include "jets/k.h"
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+u3_noun
+u3qc_rsh(u3_atom a,
+         u3_atom b,
+         u3_atom c)
+{
+  if ( !_(u3a_is_cat(a)) || (a >= 32) ) {
+    return u3m_bail(c3__fail);
+  }
+  else if ( !_(u3a_is_cat(b)) ) {
+    return 0;
+  }
+  else {
+    c3_g a_g   = a;
+    c3_w b_w   = b;
+    c3_w len_w = u3r_met(a_g, c);
+
+    if ( b_w >= len_w ) {
+      return 0;
+    }
+    else {
+      u3i_slab sab_u;
+      u3i_slab_init(&sab_u, a_g, (len_w - b_w));
+
+      u3r_chop(a_g, b_w, (len_w - b_w), 0, sab_u.buf_w, c);
+
+      return u3i_slab_mint(&sab_u);
+    }
+  }
+}
+
+u3_noun
+u3wc_rsh(u3_noun cor)
+{
+  u3_atom bloq, step;
+  u3_noun a, b;
+  u3x_mean(cor, u3x_sam_2, &a,
+                u3x_sam_3, &b, 0);
+  u3x_bite(a, &bloq, &step);
+
+  return u3qc_rsh(bloq, step, u3x_atom(b));
+}
+
+u3_noun
+u3kc_rsh(u3_noun a,
+         u3_noun b,
+         u3_noun c)
+{
+  u3_noun d = u3qc_rsh(a, b, c);
+
+  u3z(a); u3z(b); u3z(c);
+  return d;
+}
diff --git a/vere/pkg/noun/jets/c/sew.c b/vere/pkg/noun/jets/c/sew.c
new file mode 100644
index 0000000..02359f7
--- /dev/null
+++ b/vere/pkg/noun/jets/c/sew.c
@@ -0,0 +1,74 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+u3_weak
+u3qc_sew(u3_atom a,
+         u3_atom b,
+         u3_atom c,
+         u3_atom d,
+         u3_atom e
+        )
+{
+  c3_w b_w, c_w;
+  if (0 == c) return u3k(e);
+  if ( !_(u3r_safe_word(b, &b_w)) ||
+       !_(u3r_safe_word(c, &c_w)) ) {
+    return u3_none;
+  }
+  if ( !_(u3a_is_cat(a)) || (a >= 32) ) {
+    return u3m_bail(c3__fail);
+  }
+
+  c3_g a_g = a;
+  c3_w len_e_w = u3r_met(a_g, e);
+  u3i_slab sab_u;
+  c3_w* src_w;
+  c3_w len_src_w;
+  if ( _(u3a_is_cat(e)) ) {
+    len_src_w = e ? 1 : 0;
+    src_w = &e;
+  }
+  else {
+    u3a_atom* src_u = u3a_to_ptr(e);
+    len_src_w = src_u->len_w;
+    src_w = src_u->buf_w;
+  }
+  u3i_slab_init(&sab_u, a_g, c3_max(len_e_w, b_w + c_w));
+  u3r_chop_words(a_g, 0, b_w, 0, sab_u.buf_w, len_src_w, src_w);
+  u3r_chop(a_g, 0, c_w, b_w, sab_u.buf_w, d);
+  if (len_e_w > b_w + c_w) {
+    u3r_chop_words(a_g,
+             b_w + c_w,
+             len_e_w - (b_w + c_w),
+             b_w + c_w,
+             sab_u.buf_w,
+             len_src_w,
+             src_w);
+  }
+  return u3i_slab_mint(&sab_u);
+}
+
+u3_weak
+u3wc_sew(u3_noun cor)
+{
+  u3_noun a, b, c, d, e;
+  if ( (c3n == u3r_mean(cor, u3x_sam_2,  &a,
+                             u3x_sam_12, &b,
+                                    106, &c,
+                                    107, &d,
+                              u3x_sam_7, &e, 0)) ||
+       (c3n == u3ud(a)) ||
+       (c3n == u3ud(b)) ||
+       (c3n == u3ud(c)) ||
+       (c3n == u3ud(d)) ||
+       (c3n == u3ud(e)) )
+  {
+    return u3m_bail(c3__fail);
+  } else {
+    return u3qc_sew(a, b, c, d, e);
+  }
+}
diff --git a/vere/pkg/noun/jets/c/sqt.c b/vere/pkg/noun/jets/c/sqt.c
new file mode 100644
index 0000000..b20db59
--- /dev/null
+++ b/vere/pkg/noun/jets/c/sqt.c
@@ -0,0 +1,33 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+
+  u3_noun
+  u3qc_sqt(u3_atom a)
+  {
+    mpz_t a_mp, b_mp;
+
+    u3r_mp(a_mp, a);
+    mpz_init(b_mp);
+    mpz_sqrtrem(a_mp, b_mp, a_mp);
+
+    return u3nc(u3i_mp(a_mp), u3i_mp(b_mp));
+  }
+  u3_noun
+  u3wc_sqt(u3_noun cor)
+  {
+    u3_noun a;
+
+    if ( (u3_none == (a = u3r_at(u3x_sam, cor))) ||
+         (c3n == u3ud(a)) )
+    {
+      return u3m_bail(c3__exit);
+    } else {
+      return u3qc_sqt(a);
+    }
+  }
+
diff --git a/vere/pkg/noun/jets/c/swp.c b/vere/pkg/noun/jets/c/swp.c
new file mode 100644
index 0000000..4f503e7
--- /dev/null
+++ b/vere/pkg/noun/jets/c/swp.c
@@ -0,0 +1,50 @@
+/// @file
+
+#include "jets/k.h"
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+u3_noun
+u3qc_swp(u3_atom a,
+         u3_atom b)
+{
+  if ( !_(u3a_is_cat(a)) || (a >= 32) ) {
+    return u3m_bail(c3__fail);
+  }
+  c3_g a_g = a;
+  c3_w len_w = u3r_met(a_g, b);
+  u3i_slab sab_u;
+  u3i_slab_init(&sab_u, a_g, len_w);
+
+  for (c3_w i = 0; i < len_w; i++) {
+    u3r_chop(a_g, i, 1, len_w - i - 1, sab_u.buf_w, b);
+  }
+         
+  return u3i_slab_mint(&sab_u);
+}
+
+u3_noun
+u3wc_swp(u3_noun cor)
+{
+  u3_noun a, b;
+  u3x_mean(cor, u3x_sam_2, &a, u3x_sam_3, &b, 0);
+
+  if (  (c3n == u3ud(a))
+     || (c3n == u3ud(b)) )
+  {
+    return u3m_bail(c3__exit);
+  }
+
+  return u3qc_swp(a, b);
+ }
+
+u3_noun
+u3kc_swp(u3_atom a,
+         u3_atom b)
+{
+  u3_noun pro = u3qc_swp(a, b);
+  u3z(a); u3z(b);
+  return pro;
+}
diff --git a/vere/pkg/noun/jets/c/xeb.c b/vere/pkg/noun/jets/c/xeb.c
new file mode 100644
index 0000000..6a23ac1
--- /dev/null
+++ b/vere/pkg/noun/jets/c/xeb.c
@@ -0,0 +1,32 @@
+/// @file
+
+#include "jets/q.h"
+#include "jets/w.h"
+
+#include "noun.h"
+
+
+  u3_noun
+  u3qc_xeb(u3_atom a)
+  {
+    c3_w met_w = u3r_met(0, a);
+
+    if ( !_(u3a_is_cat(met_w)) ) {
+      return u3i_words(1, &met_w);
+    }
+    else return met_w;
+  }
+  u3_noun
+  u3wc_xeb(u3_noun cor)
+  {
+    u3_noun a;
+
+    if ( (u3_none == (a = u3r_at(u3x_sam, cor))) ||
+         (c3n == u3ud(a)) )
+    {
+      return u3m_bail(c3__exit);
+    } else {
+      return u3qc_xeb(a);
+    }
+  }
+