From a29c3ac5c38a6f36957f3beb9c63b73c5a867687 Mon Sep 17 00:00:00 2001
From: tromp <john.tromp@gmail.com>
Date: Mon, 17 Oct 2016 14:52:30 -0400
Subject: [PATCH] refactor types and reduce buckets from 2^16 to 2^12

---
 Makefile          |   9 +-
 equi_miner.h      | 356 ++++++++++++++------------
 hide/equi_miner.h | 619 ----------------------------------------------
 3 files changed, 209 insertions(+), 775 deletions(-)
 delete mode 100644 hide/equi_miner.h

diff --git a/Makefile b/Makefile
index 9026d75..8c81810 100644
--- a/Makefile
+++ b/Makefile
@@ -11,13 +11,16 @@ equi1:	equi.h equi_miner.h equi_miner.cpp Makefile
 	$(GPP) equi_miner.cpp blake/blake2b.cpp -o equi1
 
 equi1g:	equi.h equi_miner.h equi_miner.cpp Makefile
-	g++ -g -DSPARK equi_miner.cpp blake/blake2b.cpp -pthread -o equi1g
+	g++ -g -DLOGSPARK -DSPARKSCALE=11 equi_miner.cpp blake/blake2b.cpp -pthread -o equi1g
 
 equi965:	equi.h equi_miner.h equi_miner.cpp Makefile
 	$(GPP) -DWN=96 -DWK=5 equi_miner.cpp blake/blake2b.cpp -o equi965
 
 equi1445:	equi.h equi_miner.h equi_miner.cpp Makefile
-	$(GPP) -DWN=144 -DWK=5 -DXWITHASH equi_miner.cpp blake/blake2b.cpp -o equi1445
+	$(GPP) -DWN=144 -DWK=5 equi_miner.cpp blake/blake2b.cpp -o equi1445
+
+dev1:	equi.h dev_miner.h dev_miner.cpp Makefile
+	$(GPP) -DRESTBITS=8 dev_miner.cpp blake/blake2b.cpp -o dev1
 
 eqcuda:	equi_miner.cu equi.h blake2b.cu Makefile
 	nvcc -arch sm_35 equi_miner.cu blake/blake2b.cpp -o eqcuda
@@ -32,7 +35,7 @@ verify:	equi.h equi.c Makefile
 	g++ -g equi.c blake/blake2b.cpp -o verify
 
 bench:	equi1
-	time ./equi1 -n 1000 -r 100
+	time ./equi1 -r 10
 
 test:	equi verify Makefile
 	time ./equi -h "" -n 0 -t 1 -s | grep ^Sol | ./verify -h "" -n 0
diff --git a/equi_miner.h b/equi_miner.h
index 537c9d5..797077d 100644
--- a/equi_miner.h
+++ b/equi_miner.h
@@ -24,6 +24,7 @@
 #include <pthread.h>
 #include <assert.h>
 
+typedef uint16_t u16;
 typedef uint64_t u64;
 
 #ifdef ATOMIC
@@ -34,7 +35,7 @@ typedef u32 au32;
 #endif
 
 #ifndef RESTBITS
-#define RESTBITS	4
+#define RESTBITS	8
 #endif
 
 // 2_log of number of buckets
@@ -47,7 +48,7 @@ static const u32 SLOTBITS = RESTBITS+1+1;
 // number of slots per bucket
 static const u32 NSLOTS = 1<<SLOTBITS;
 // number of per-xhash slots
-static const u32 XFULL = NSLOTS/4;
+static const u32 XFULL = 64;
 // SLOTBITS mask
 static const u32 SLOTMASK = NSLOTS-1;
 // number of possible values of xhash (rest of n) bits
@@ -57,20 +58,12 @@ static const u32 NBLOCKS = (NHASHES+HASHESPERBLAKE-1)/HASHESPERBLAKE;
 // nothing larger found in 100000 runs
 static const u32 MAXSOLS = 8;
 
-// scaling factor for showing bucketsize histogra as sparkline
-#ifndef SPARKSCALE
-#define SPARKSCALE	(40 << (BUCKBITS-12))
-#endif
-
 // tree node identifying its children as two different slots in
 // a bucket on previous layer with the same rest bits (x-tra hash)
 struct tree {
   unsigned bucketid : BUCKBITS;
   unsigned slotid0  : SLOTBITS;
   unsigned slotid1  : SLOTBITS;
-#ifndef XWITHASH
-  unsigned xhash    : RESTBITS;
-#endif
 
 // layer 0 has no children bit needs to encode index
   u32 getindex() const {
@@ -82,36 +75,49 @@ struct tree {
   }
 };
 
-union htunit {
-  tree attr;
-  u32 hash;
+union hashunit {
+  u32 word;
   uchar bytes[sizeof(u32)];
 };
 
+#define WORDS(bits)	((bits + 31) / 32)
+#define HASHWORDS0 WORDS(WN - DIGITBITS + RESTBITS)
+#define HASHWORDS1 WORDS(WN - 2*DIGITBITS + RESTBITS)
+
+struct slot0 {
+  tree attr;
+  hashunit hash[HASHWORDS0];
+};
+
+struct slot1 {
+  tree attr;
+  hashunit hash[HASHWORDS1];
+};
+
 // a bucket is NSLOTS treenodes
-typedef htunit bucket[NSLOTS];
+typedef slot0 bucket0[NSLOTS];
+typedef slot1 bucket1[NSLOTS];
 // the N-bit hash consists of K+1 n-bit "digits"
 // each of which corresponds to a layer of NBUCKETS buckets
-typedef bucket digit[NBUCKETS];
+typedef bucket0 digit0[NBUCKETS];
+typedef bucket1 digit1[NBUCKETS];
 
 // size (in bytes) of hash in round 0 <= r < WK
 u32 hashsize(const u32 r) {
-#ifdef XWITHASH
   const u32 hashbits = WN - (r+1) * DIGITBITS + RESTBITS;
-#else
-  const u32 hashbits = WN - (r+1) * DIGITBITS;
-#endif
   return (hashbits + 7) / 8;
 }
 
-
-u32 htunits(u32 bytes) {
-  return (bytes + sizeof(htunit) - 1) / sizeof(htunit);
+u32 hashwords(u32 bytes) {
+  return (bytes + 3) / 4;
 }
 
 // manages hash and tree data
 struct htalloc {
-  htunit *trees[WK];
+  u32 *heap0;
+  u32 *heap1;
+  bucket0 *trees0[(WK+1)/2];
+  bucket1 *trees1[WK/2];
   u32 alloced;
   htalloc() {
     alloced = 0;
@@ -129,25 +135,17 @@ struct htalloc {
 // 7      0 2 4 6 . G G   1 3 5 7 H H
 // 8      0 2 4 6 8 . I   1 3 5 7 H H
     assert(DIGITBITS >= 16); // ensures hashes shorten by 1 unit every 2 digits
-    digit *heap[2];
-    for (u32 i =0; i < 2; i++)
-      heap[i] = (digit *)alloc(1 + htunits(hashsize(i)), sizeof(digit));
+    heap0 = (u32 *)alloc(1, sizeof(digit0));
+    heap1 = (u32 *)alloc(1, sizeof(digit1));
     for (int r=0; r<WK; r++)
-      trees[r]  = (htunit *)heap[r&1] + r/2;
+      if ((r&1) == 0)
+        trees0[r/2]  = (bucket0 *)(heap0 + r/2);
+      else
+        trees1[r/2]  = (bucket1 *)(heap1 + r/2);
   }
   void dealloctrees() {
-    for (u32 i =0; i < 2; i++)
-      free(trees[i]);
-  }
-  u32 slotsize(const u32 r) const {
-    return 1 + htunits(hashsize(r&1));
-  }
-  // size (in htunits) of bucket in round 0 <= r < WK
-  u32 bucketsize(const u32 r) const {
-    return NSLOTS * slotsize(r);
-  }
-  htunit *getbucket(u32 r, u32 bid) const {
-    return &trees[r][bid * bucketsize(r)];
+    free(heap0);
+    free(heap1);
   }
   void *alloc(const u32 n, const u32 sz) {
     void *mem  = calloc(n, sz);
@@ -166,7 +164,7 @@ u32 min(const u32 a, const u32 b) {
 struct equi {
   blake2b_state blake_ctx;
   htalloc hta;
-  bsizes *nslots;
+  bsizes *nslots; // PUT IN BUCKET STRUCT
   proof *sols;
   au32 nsols;
   u32 nthreads;
@@ -175,13 +173,13 @@ struct equi {
   u32 bfull;
   pthread_barrier_t barry;
   equi(const u32 n_threads) {
-    assert(sizeof(htunit) == 4);
+    assert(sizeof(hashunit) == 4);
     nthreads = n_threads;
     const int err = pthread_barrier_init(&barry, NULL, nthreads);
     assert(!err);
     hta.alloctrees();
-    nslots    = (bsizes *)hta.alloc(2 * NBUCKETS, sizeof(au32));
-    sols = (proof *)hta.alloc(MAXSOLS, sizeof(proof));
+    nslots = (bsizes *)hta.alloc(2 * NBUCKETS, sizeof(au32));
+    sols   =  (proof *)hta.alloc(MAXSOLS, sizeof(proof));
   }
   ~equi() {
     hta.dealloctrees();
@@ -193,40 +191,51 @@ struct equi {
     memset(nslots, 0, NBUCKETS * sizeof(au32)); // only nslots[0] needs zeroing
     nsols = 0;
   }
-  u32 findslot(const u32 r, const u32 bucketi) {
+  u32 getslot(const u32 r, const u32 bucketi) {
 #ifdef ATOMIC
     return std::atomic_fetch_add_explicit(&nslots[r&1][bucketi], 1U, std::memory_order_relaxed);
 #else
     return nslots[r&1][bucketi]++;
 #endif
   }
-  u32 getnslots(const u32 r, const u32 bid) {
+  u32 getnslots(const u32 r, const u32 bid) { // SHOULD BE METHOD IN BUCKET STRUCT
     au32 &nslot = nslots[r&1][bid];
     const u32 n = min(nslot, NSLOTS);
     nslot = 0;
     return n;
   }
-  void listindices(u32 r, const tree t, u32 *indices) {
+  void orderindices(u32 *indices, u32 size) {
+    if (indices[0] > indices[size]) {
+      for (u32 i=0; i < size; i++) {
+        const u32 tmp = indices[i];
+        indices[i] = indices[size+i];
+        indices[size+i] = tmp;
+      }
+    }
+  }
+  void listindices0(u32 r, const tree t, u32 *indices) {
     if (r == 0) {
       *indices = t.getindex();
       return;
     }
-    const htunit *bt = hta.getbucket(--r,t.bucketid);
+    const bucket1 &buck = hta.trees1[--r/2][t.bucketid];
     const u32 size = 1 << r;
     u32 *indices1 = indices + size;
-    listindices(r, bt[t.slotid0 * hta.slotsize(r)].attr, indices);
-    listindices(r, bt[t.slotid1 * hta.slotsize(r)].attr, indices1);
-    if (*indices > *indices1) {
-      for (u32 i=0; i < size; i++) {
-        const u32 tmp = indices[i];
-        indices[i] = indices1[i];
-        indices1[i] = tmp;
-      }
-    }
+    listindices1(r, buck[t.slotid0].attr, indices);
+    listindices1(r, buck[t.slotid1].attr, indices1);
+    orderindices(indices, size);
+  }
+  void listindices1(u32 r, const tree t, u32 *indices) {
+    const bucket0 &buck = hta.trees0[--r/2][t.bucketid];
+    const u32 size = 1 << r;
+    u32 *indices1 = indices + size;
+    listindices0(r, buck[t.slotid0].attr, indices);
+    listindices0(r, buck[t.slotid1].attr, indices1);
+    orderindices(indices, size);
   }
   void candidate(const tree t) {
     proof prf;
-    listindices(WK, t, prf);
+    listindices1(WK, t, prf); // assume WK odd
     qsort(prf, PROOFSIZE, sizeof(u32), &compu32);
     for (u32 i=1; i<PROOFSIZE; i++)
       if (prf[i] <= prf[i-1])
@@ -237,24 +246,28 @@ struct equi {
     u32 soli = nsols++;
 #endif
     if (soli < MAXSOLS)
-      listindices(WK, t, sols[soli]);
+      listindices1(WK, t, sols[soli]); // assume WK odd
   }
   void showbsizes(u32 r) {
-#if defined(HIST) || defined(SPARK)
-    u32 bsizes[NSLOTS+1];
-    memset(bsizes, 0, (NSLOTS+1) * sizeof(u32));
+#if defined(HIST) || defined(SPARK) || defined(LOGSPARK)
+    u32 binsizes[65];
+    memset(binsizes, 0, 65 * sizeof(u32));
     for (u32 bucketid = 0; bucketid < NBUCKETS; bucketid++) {
-      u32 bsize = nslots[r&1][bucketid];
-      if (bsize < NSLOTS)
-        bsizes[bsize]++;
-      else
-        bsizes[NSLOTS]++;
+      u32 bsize = min(nslots[r&1][bucketid], NSLOTS) >> (SLOTBITS-6);
+      binsizes[bsize]++;
     }
-    for (u32 i=0; i<=NSLOTS; i++) {
+    for (u32 i=0; i < 65; i++) {
 #ifdef HIST
-      printf(" %d:%d", i, bsizes[i]);
+      printf(" %d:%d", i, binsizes[i]);
 #else
-      printf("\342\226%c", '\201'+bsizes[i]/SPARKSCALE);
+#ifdef SPARK
+      u32 sparks = binsizes[i] / SPARKSCALE;
+#else
+      u32 sparks = 0;
+      for (u32 bs = binsizes[i]; bs; bs >>= 1) sparks++;
+      sparks = sparks * 7 / SPARKSCALE;
+#endif
+      printf("\342\226%c", '\201' + sparks);
 #endif
     }
     printf("\n");
@@ -263,58 +276,64 @@ struct equi {
 
   struct htlayout {
     htalloc hta;
-    u32 prevhtunits;
-    u32 nexthtunits;
-    u32 prevslotunits;
-    u32 nextslotunits;
+    u32 prevhashunits;
+    u32 nexthashunits;
     u32 dunits;
     u32 prevbo;
     u32 nextbo;
-    htunit *buck;
-    htunit *hashbase;
   
-    htlayout(equi *eq, u32 r): hta(eq->hta), prevhtunits(0), prevslotunits(0), dunits(0) {
+    htlayout(equi *eq, u32 r): hta(eq->hta), prevhashunits(0), dunits(0) {
       u32 nexthashbytes = hashsize(r);
-      nexthtunits = htunits(nexthashbytes);
-      nextslotunits = 1 + htunits(hashsize(r&1));
+      nexthashunits = hashwords(nexthashbytes);
       prevbo = 0;
-      nextbo = nexthtunits * sizeof(htunit) - nexthashbytes; // 0-3
+      nextbo = nexthashunits * sizeof(hashunit) - nexthashbytes; // 0-3
       if (r) {
         u32 prevhashbytes = hashsize(r-1);
-        prevhtunits = htunits(prevhashbytes);
-        prevslotunits = 1 + htunits(hashsize((r-1)&1));
-        prevbo = prevhtunits * sizeof(htunit) - prevhashbytes; // 0-3
-        dunits = prevhtunits - nexthtunits;
+        prevhashunits = hashwords(prevhashbytes);
+        prevbo = prevhashunits * sizeof(hashunit) - prevhashbytes; // 0-3
+        dunits = prevhashunits - nexthashunits;
       }
     }
-    void setbucket(u32 r, u32 bid) {
-      buck = hta.getbucket(r, bid);
-      hashbase = buck + 1;
-    }
-    u32 getxhash(const u32 slot, const htunit *hash) const {
-#ifdef XWITHASH
-      return hash->bytes[prevbo] & 0xf;
+    u32 getxhash0(const slot0* pslot) const {
+#if WN == 200 && RESTBITS == 4
+      return pslot->hash->bytes[prevbo] >> 4;
+#elif WN == 200 && RESTBITS == 8
+      return (pslot->hash->bytes[prevbo] & 0xf) << 4 | pslot->hash->bytes[prevbo+1] >> 4;
+#elif WN == 144 && RESTBITS == 4
+      return pslot->hash->bytes[prevbo] & 0xf;
 #else
-      return buck[slot * prevslotunits].attr.xhash;
+#error non implemented
 #endif
     }
-    bool equal(const htunit *hash0, const htunit *hash1) const {
-      return hash0[prevhtunits-1].hash == hash1[prevhtunits-1].hash;
+    u32 getxhash1(const slot1* pslot) const {
+#if WN == 200 && RESTBITS == 4
+      return pslot->hash->bytes[prevbo] & 0xf;
+#elif WN == 200 && RESTBITS == 8
+      return pslot->hash->bytes[prevbo];
+#elif WN == 144 && RESTBITS == 4
+      return pslot->hash->bytes[prevbo] & 0xf;
+#else
+#error non implemented
+#endif
     }
-    htunit *addtree(u32 r, tree t, u32 bid, u32 slot) {
-      htunit *buck = hta.getbucket(r,bid);
-      htunit *slotree = buck + slot * nextslotunits;
-      slotree->attr = t;
-      return slotree + 1;
+    bool equal(const hashunit *hash0, const hashunit *hash1) const {
+      return hash0[prevhashunits-1].word == hash1[prevhashunits-1].word;
     }
   };
 
   struct collisiondata {
 #ifdef XBITMAP
+#if NSLOTS > 64
+#error cant use XBITMAP with more than 64 slots
+#endif
     u64 xhashmap[NRESTS];
     u64 xmap;
 #else
+#if RESTBITS <= 6
     typedef uchar xslot;
+#else
+    typedef u16 xslot;
+#endif
     xslot nxhashslots[NRESTS];
     xslot xhashslots[NRESTS][XFULL];
     xslot *xx;
@@ -371,102 +390,134 @@ struct equi {
     const u32 hashbytes = hashsize(0);
     for (u32 block = id; block < NBLOCKS; block += nthreads) {
       state = blake_ctx;
-      const u32 leb = htole32(block);
+      u32 leb = htole32(block);
       blake2b_update(&state, (uchar *)&leb, sizeof(u32));
       blake2b_final(&state, hash, HASHOUT);
       for (u32 i = 0; i<HASHESPERBLAKE; i++) {
         const uchar *ph = hash + i * WN/8;
 #if BUCKBITS == 16 && RESTBITS == 4
         const u32 bucketid = ((u32)ph[0] << 8) | ph[1];
-#ifndef XWITHASH
-        const u32 xhash = ph[2] >> 4;
-#endif
+#elif BUCKBITS == 12 && RESTBITS == 8
+        const u32 bucketid = ((u32)ph[0] << 4) | ph[1] >> 4;
 #elif BUCKBITS == 20 && RESTBITS == 4
         const u32 bucketid = ((((u32)ph[0] << 8) | ph[1]) << 4) | ph[2] >> 4;
-#ifndef XWITHASH
-        const u32 xhash = ph[2] & 0xf;
-#endif
 #elif BUCKBITS == 12 && RESTBITS == 4
         const u32 bucketid = ((u32)ph[0] << 4) | ph[1] >> 4;
         const u32 xhash = ph[1] & 0xf;
 #else
 #error not implemented
 #endif
-        const u32 slot = findslot(0, bucketid);
+        const u32 slot = getslot(0, bucketid);
         if (slot >= NSLOTS) {
           bfull++;
           continue;
         }
         tree leaf;
         leaf.setindex(block*HASHESPERBLAKE+i);
-#ifndef XWITHASH
-        leaf.xhash = xhash;
-#endif
-        htunit *dest = htl.addtree(0, leaf, bucketid, slot);
-        memcpy(dest->bytes+htl.nextbo, ph+WN/8-hashbytes, hashbytes);
+        slot0 &s = hta.trees0[0][bucketid][slot];
+        s.attr = leaf;
+        memcpy(s.hash->bytes+htl.nextbo, ph+WN/8-hashbytes, hashbytes);
       }
     }
   }
   
-  void digitr(const u32 r, const u32 id) {
+  void digitodd(const u32 r, const u32 id) {
     htlayout htl(this, r);
     collisiondata cd;
     for (u32 bucketid=id; bucketid < NBUCKETS; bucketid += nthreads) {
       cd.clear();
-      htl.setbucket(r-1, bucketid);
-      u32 bsize = getnslots(r-1, bucketid);
+      slot0 *buck = htl.hta.trees0[(r-1)/2][bucketid]; // optimize by updating previous buck?!
+      u32 bsize = getnslots(r-1, bucketid);       // optimize by putting bucketsize with block?!
       for (u32 s1 = 0; s1 < bsize; s1++) {
-        const htunit *hash1 = htl.hashbase + s1 * htl.prevslotunits;
-        if (!cd.addslot(s1, htl.getxhash(s1, hash1))) {
+        const slot0 *pslot1 = buck + s1;          // optimize by updating previous pslot1?!
+        if (!cd.addslot(s1, htl.getxhash0(pslot1))) {
           xfull++;
           continue;
         }
         for (; cd.nextcollision(); ) {
           const u32 s0 = cd.slot();
-          const htunit *hash0 = htl.hashbase + s0 * htl.prevslotunits;
-          if (htl.equal(hash0, hash1)) {
+          const slot0 *pslot0 = buck + s0;
+          if (htl.equal(pslot0->hash, pslot1->hash)) {
             hfull++;
             continue;
           }
           u32 xorbucketid;
-          u32 xhash;
-#if BUCKBITS == 16 && RESTBITS == 4
-#ifdef XWITHASH
-          xhash = hash0->bytes[htl.prevbo+2] ^ hash1->bytes[htl.prevbo+2];
-#error not yet implemented
-#else
-          xorbucketid = ((u32)(hash0->bytes[htl.prevbo]^hash1->bytes[htl.prevbo]) << 8)
-            | (hash0->bytes[htl.prevbo+1]^hash1->bytes[htl.prevbo+1]);
-          xhash = hash0->bytes[htl.prevbo+2] ^ hash1->bytes[htl.prevbo+2];
-          if (r&1) {
-            xorbucketid = ((xorbucketid & 0xfff) << 4) | (xhash >> 4);
-            xhash &= 0xf;
-          } else xhash >>= 4;
-#endif
-#elif BUCKBITS == 20 && RESTBITS == 4 && defined XWITHASH
-          xhash = hash0->bytes[htl.prevbo+3] ^ hash1->bytes[htl.prevbo+3];
-          xorbucketid = ((((u32)(hash0->bytes[htl.prevbo+1]^hash1->bytes[htl.prevbo+1]) << 8) | (hash0->bytes[htl.prevbo+2]^hash1->bytes[htl.prevbo+2])) << 4) | xhash >> 4;
-          xhash &= 0xf;
-#elif BUCKBITS == 12 && RESTBITS == 4
-          xhash = hash0->bytes[htl.prevbo+1] ^ hash1->bytes[htl.prevbo+1];
-          xorbucketid = ((u32)(hash0->bytes[htl.prevbo]^hash1->bytes[htl.prevbo]) << 4) | xhash >> 4;
-          xhash &= 0xf;
+          const uchar *bytes0 = pslot0->hash->bytes, *bytes1 = pslot1->hash->bytes;
+#if WN == 200 && BUCKBITS == 12 && RESTBITS == 8
+          xorbucketid = (((u32)(bytes0[htl.prevbo+1] ^ bytes1[htl.prevbo+1]) & 0xf) << 8)
+                             | (bytes0[htl.prevbo+2] ^ bytes1[htl.prevbo+2]);
+#elif WN == 144 && BUCKBITS == 20 && RESTBITS == 4
+          xorbucketid = ((((u32)(bytes0[htl.prevbo+1] ^ bytes1[htl.prevbo+1]) << 8)
+                              | (bytes0[htl.prevbo+2] ^ bytes1[htl.prevbo+2])) << 4)
+                              | (bytes0[htl.prevbo+3] ^ bytes1[htl.prevbo+3]) >> 4;
+#elif WN == 96 && BUCKBITS == 12 && RESTBITS == 4
+          xorbucketid = ((u32)(bytes0[htl.prevbo+1] ^ bytes1[htl.prevbo+1]) << 4)
+                            | (bytes0[htl.prevbo+2] ^ bytes1[htl.prevbo+2]) >> 4;
 #else
 #error not implemented
 #endif
-          const u32 xorslot = findslot(r, xorbucketid);
+          const u32 xorslot = getslot(r, xorbucketid);
           if (xorslot >= NSLOTS) {
             bfull++;
             continue;
           }
           tree xort; xort.bucketid = bucketid;
           xort.slotid0 = s0; xort.slotid1 = s1;
-#ifndef XWITHASH
-          xort.xhash = xhash;
+          slot1 &xs = htl.hta.trees1[r/2][xorbucketid][xorslot];
+          xs.attr = xort;
+          for (u32 i=htl.dunits; i < htl.prevhashunits; i++)
+            xs.hash[i-htl.dunits].word = pslot0->hash[i].word ^ pslot1->hash[i].word;
+        }
+      }
+    }
+  }
+  
+  void digiteven(const u32 r, const u32 id) {
+    htlayout htl(this, r);
+    collisiondata cd;
+    for (u32 bucketid=id; bucketid < NBUCKETS; bucketid += nthreads) {
+      cd.clear();
+      slot1 *buck = htl.hta.trees1[(r-1)/2][bucketid]; // OPTIMIZE BY UPDATING PREVIOUS
+      u32 bsize = getnslots(r-1, bucketid);
+      for (u32 s1 = 0; s1 < bsize; s1++) {
+        const slot1 *pslot1 = buck + s1;          // OPTIMIZE BY UPDATING PREVIOUS
+        if (!cd.addslot(s1, htl.getxhash1(pslot1))) {
+          xfull++;
+          continue;
+        }
+        for (; cd.nextcollision(); ) {
+          const u32 s0 = cd.slot();
+          const slot1 *pslot0 = buck + s0;
+          if (htl.equal(pslot0->hash, pslot1->hash)) {
+            hfull++;
+            continue;
+          }
+          u32 xorbucketid;
+          const uchar *bytes0 = pslot0->hash->bytes, *bytes1 = pslot1->hash->bytes;
+#if WN == 200 && BUCKBITS == 12 && RESTBITS == 8
+          xorbucketid = ((u32)(bytes0[htl.prevbo+1] ^ bytes1[htl.prevbo+1]) << 4)
+                            | (bytes0[htl.prevbo+2] ^ bytes1[htl.prevbo+2]) >> 4;
+#elif WN == 144 && BUCKBITS == 20 && RESTBITS == 4
+          xorbucketid = ((((u32)(bytes0[htl.prevbo+1] ^ bytes1[htl.prevbo+1]) << 8)
+                              | (bytes0[htl.prevbo+2] ^ bytes1[htl.prevbo+2])) << 4)
+                              | (bytes0[htl.prevbo+3] ^ bytes1[htl.prevbo+3]) >> 4;
+#elif WN == 96 && BUCKBITS == 12 && RESTBITS == 4
+          xorbucketid = ((u32)(bytes0[htl.prevbo+1] ^ bytes1[htl.prevbo+1]) << 4)
+                            | (bytes0[htl.prevbo+2] ^ bytes1[htl.prevbo+2]) >> 4;
+#else
+#error not implemented
 #endif
-          htunit *xorhash = htl.addtree(r, xort, xorbucketid, xorslot);
-          for (u32 i=htl.dunits; i < htl.prevhtunits; i++)
-            xorhash[i-htl.dunits].hash = hash0[i].hash ^ hash1[i].hash;
+          const u32 xorslot = getslot(r, xorbucketid);
+          if (xorslot >= NSLOTS) {
+            bfull++;
+            continue;
+          }
+          tree xort; xort.bucketid = bucketid;
+          xort.slotid0 = s0; xort.slotid1 = s1;
+          slot0 &xs = htl.hta.trees0[r/2][xorbucketid][xorslot];
+          xs.attr = xort;
+          for (u32 i=htl.dunits; i < htl.prevhashunits; i++)
+            xs.hash[i-htl.dunits].word = pslot0->hash[i].word ^ pslot1->hash[i].word;
         }
       }
     }
@@ -477,16 +528,16 @@ struct equi {
     htlayout htl(this, WK);
     for (u32 bucketid = id; bucketid < NBUCKETS; bucketid += nthreads) {
       cd.clear();
-      htl.setbucket(WK-1, bucketid);
+      slot0 *buck = htl.hta.trees0[(WK-1)/2][bucketid];
       u32 bsize = getnslots(WK-1, bucketid);
       for (u32 s1 = 0; s1 < bsize; s1++) {
-        const htunit *hash1 = htl.hashbase + s1 * htl.prevslotunits;
-        if (!cd.addslot(s1, htl.getxhash(s1, hash1)))
+        const slot0 *pslot1 = buck + s1;
+        if (!cd.addslot(s1, htl.getxhash0(pslot1))) // assume WK odd
           continue;
         for (; cd.nextcollision(); ) {
           const u32 s0 = cd.slot();
-          const htunit *hash0 = htl.hashbase + s0 * htl.prevslotunits;
-          if (htl.equal(hash0, hash1)) {
+          const slot0 *pslot0 = buck + s0;
+          if (htl.equal(pslot0->hash, pslot1->hash)) {
             tree xort; xort.bucketid = bucketid;
             xort.slotid0 = s0; xort.slotid1 = s1;
             candidate(xort);
@@ -511,7 +562,6 @@ void barrier(pthread_barrier_t *barry) {
   }
 }
 
-
 void *worker(void *vp) {
   thread_ctx *tp = (thread_ctx *)vp;
   equi *eq = tp->eq;
@@ -530,7 +580,7 @@ void *worker(void *vp) {
     if (tp->id == 0)
       printf("Digit %d", r);
     barrier(&eq->barry);
-    eq->digitr(r, tp->id);
+    r&1 ? eq->digitodd(r, tp->id) : eq->digiteven(r, tp->id);
     barrier(&eq->barry);
     if (tp->id == 0) {
       printf(" x%d b%d h%d\n", eq->xfull, eq->bfull, eq->hfull);
diff --git a/hide/equi_miner.h b/hide/equi_miner.h
deleted file mode 100644
index f55f801..0000000
--- a/hide/equi_miner.h
+++ /dev/null
@@ -1,619 +0,0 @@
-// Equihash solver
-// Copyright (c) 2016 John Tromp
-
-// Fix N, K, such that n = N/(k+1) is integer
-// Fix M = 2^{n+1} hashes each of length N bits,
-// H_0, ... , H_{M-1}, generated fom (n+1)-bit indices.
-// Problem: find binary tree on 2^K distinct indices,
-// for which the exclusive-or of leaf hashes is all 0s.
-// Additionally, it should satisfy the Wagner conditions:
-// for each height i subtree, the exclusive-or
-// of its 2^i corresponding hashes starts with i*n 0 bits,
-// and for i>0 the leftmost leaf of its left subtree
-// is less than the leftmost leaf of its right subtree
-
-// The algorithm below solves this by maintaining the trees
-// in a graph of K layers, each split into buckets
-// with buckets indexed by the first n-RESTBITS bits following
-// the i*n 0s, each bucket having 4 * 2^RESTBITS slots,
-// twice the number of subtrees expected to land there.
-
-#include "equi.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <pthread.h>
-#include <assert.h>
-
-typedef uint64_t u64;
-
-#ifdef ATOMIC
-#include <atomic>
-typedef std::atomic<u32> au32;
-#else
-typedef u32 au32;
-#endif
-
-#ifndef RESTBITS
-#define RESTBITS	4
-#endif
-
-// 2_log of number of buckets
-#define BUCKBITS (DIGITBITS-RESTBITS)
-
-// number of buckets
-static const u32 NBUCKETS = 1<<BUCKBITS;
-// 2_log of number of slots per bucket
-static const u32 SLOTBITS = RESTBITS+1+1;
-// number of slots per bucket
-static const u32 NSLOTS = 1<<SLOTBITS;
-// number of per-xhash slots
-static const u32 XFULL = NSLOTS/4;
-// SLOTBITS mask
-static const u32 SLOTMASK = NSLOTS-1;
-// number of possible values of xhash (rest of n) bits
-static const u32 NRESTS = 1<<RESTBITS;
-// number of blocks of hashes extracted from single 512 bit blake2b output
-static const u32 NBLOCKS = (NHASHES+HASHESPERBLAKE-1)/HASHESPERBLAKE;
-// nothing larger found in 100000 runs
-static const u32 MAXSOLS = 8;
-
-// scaling factor for showing bucketsize histogra as sparkline
-#ifndef SPARKSCALE
-#define SPARKSCALE	(40 << (BUCKBITS-12))
-#endif
-
-// tree node identifying its children as two different slots in
-// a bucket on previous layer with the same rest bits (x-tra hash)
-struct tree {
-  unsigned bucketid : BUCKBITS;
-  unsigned slotid0  : SLOTBITS;
-  unsigned slotid1  : SLOTBITS;
-#ifdef XINTREE
-  unsigned xhash    : RESTBITS;
-#endif
-
-// layer 0 has no children bit needs to encode index
-  u32 getindex() const {
-    return (bucketid << SLOTBITS) | slotid0;
-  }
-  void setindex(const u32 idx) {
-    slotid0 = idx & SLOTMASK;
-    bucketid = idx >> SLOTBITS;
-  }
-};
-
-union hashunit {
-  u32 word;
-  uchar bytes[sizeof(u32)];
-};
-
-#define WORDS(bits)	((bits + 31) / 32)
-#ifdef XINTREE
-#define HASHWORDS0 WORDS(WN - DIGITBITS)
-#define HASHWORDS1 WORDS(WN - 2*DIGITBITS)
-#else
-#define HASHWORDS0 WORDS(WN - DIGITBITS + RESTBITS)
-#define HASHWORDS1 WORDS(WN - 2*DIGITBITS + RESTBITS)
-#endif
-
-struct slot0 {
-  tree attr;
-  hashunit hash[HASHWORDS0];
-};
-
-struct slot1 {
-  tree attr;
-  hashunit hash[HASHWORDS1];
-};
-
-// a bucket is NSLOTS treenodes
-typedef slot0 bucket0[NSLOTS];
-typedef slot0 bucket1[NSLOTS]; // use bigger one for now
-// the N-bit hash consists of K+1 n-bit "digits"
-// each of which corresponds to a layer of NBUCKETS buckets
-typedef bucket0 digit0[NBUCKETS];
-typedef bucket1 digit1[NBUCKETS];
-
-// size (in bytes) of hash in round 0 <= r < WK
-u32 hashsize(const u32 r) {
-#ifdef XINTREE
-  const u32 hashbits = WN - (r+1) * DIGITBITS;
-#else
-  const u32 hashbits = WN - (r+1) * DIGITBITS + RESTBITS;
-#endif
-  return (hashbits + 7) / 8;
-}
-
-u32 hashwords(u32 bytes) {
-  return (bytes + 3) / 4;
-}
-
-// manages hash and tree data
-struct htalloc {
-  bucket0 *trees[WK];
-  u32 alloced;
-  htalloc() {
-    alloced = 0;
-  }
-  void alloctrees() {
-// optimize xenoncat's fixed memory layout, avoiding any waste
-// digit  trees  hashes  trees hashes
-// 0      0 A A A A A A   . . . . . .
-// 1      0 A A A A A A   1 B B B B B
-// 2      0 2 C C C C C   1 B B B B B
-// 3      0 2 C C C C C   1 3 D D D D
-// 4      0 2 4 E E E E   1 3 D D D D
-// 5      0 2 4 E E E E   1 3 5 F F F
-// 6      0 2 4 6 . G G   1 3 5 F F F
-// 7      0 2 4 6 . G G   1 3 5 7 H H
-// 8      0 2 4 6 8 . I   1 3 5 7 H H
-    assert(DIGITBITS >= 16); // ensures hashes shorten by 1 unit every 2 digits
-    digit0 *heap[2];
-    heap[0] = (digit0 *)alloc(1, sizeof(digit0));
-    heap[1] = (digit1 *)alloc(1, sizeof(digit0)); // still need to exploit HASHWORDS1<HASHWORDS0
-    for (int r=0; r<WK; r++)
-      trees[r]  = (bucket0 *)heap[r&1] + r/2;
-  }
-  void dealloctrees() {
-    free(trees[0]);
-    free(trees[1]);
-  }
-  void *alloc(const u32 n, const u32 sz) {
-    void *mem  = calloc(n, sz);
-    assert(mem);
-    alloced += n * sz;
-    return mem;
-  }
-};
-
-typedef au32 bsizes[NBUCKETS];
-
-u32 min(const u32 a, const u32 b) {
-  return a < b ? a : b;
-}
-
-struct equi {
-  blake2b_state blake_ctx;
-  htalloc hta;
-  bsizes *nslots;
-  proof *sols;
-  au32 nsols;
-  u32 nthreads;
-  u32 xfull;
-  u32 hfull;
-  u32 bfull;
-  pthread_barrier_t barry;
-  equi(const u32 n_threads) {
-    assert(sizeof(hashunit) == 4);
-    nthreads = n_threads;
-    const int err = pthread_barrier_init(&barry, NULL, nthreads);
-    assert(!err);
-    hta.alloctrees();
-    nslots = (bsizes *)hta.alloc(2 * NBUCKETS, sizeof(au32));
-    sols   =  (proof *)hta.alloc(MAXSOLS, sizeof(proof));
-  }
-  ~equi() {
-    hta.dealloctrees();
-    free(nslots);
-    free(sols);
-  }
-  void setnonce(const char *header, u32 nonce) {
-    setheader(&blake_ctx, header, nonce);
-    memset(nslots, 0, NBUCKETS * sizeof(au32)); // only nslots[0] needs zeroing
-    nsols = 0;
-  }
-  u32 getslot(const u32 r, const u32 bucketi) {
-#ifdef ATOMIC
-    return std::atomic_fetch_add_explicit(&nslots[r&1][bucketi], 1U, std::memory_order_relaxed);
-#else
-    return nslots[r&1][bucketi]++;
-#endif
-  }
-  u32 getnslots(const u32 r, const u32 bid) {
-    au32 &nslot = nslots[r&1][bid];
-    const u32 n = min(nslot, NSLOTS);
-    nslot = 0;
-    return n;
-  }
-  void orderindices(u32 *indices, u32 size) {
-    if (indices[0] > indices[size]) {
-      for (u32 i=0; i < size; i++) {
-        const u32 tmp = indices[i];
-        indices[i] = indices[size+i];
-        indices[size+i] = tmp;
-      }
-    }
-  }
-  void listindices0(u32 r, const tree t, u32 *indices) {
-    if (r == 0) {
-      *indices = t.getindex();
-      return;
-    }
-    const bucket0 &buck = hta.trees[--r][t.bucketid];
-    const u32 size = 1 << r;
-    u32 *indices1 = indices + size;
-    listindices1(r, buck[t.slotid0].attr, indices);
-    listindices1(r, buck[t.slotid1].attr, indices1);
-    orderindices(indices, size);
-  }
-  void listindices1(u32 r, const tree t, u32 *indices) {
-    const bucket0 &buck = hta.trees[--r][t.bucketid];
-    const u32 size = 1 << r;
-    u32 *indices1 = indices + size;
-    listindices0(r, buck[t.slotid0].attr, indices);
-    listindices0(r, buck[t.slotid1].attr, indices1);
-    orderindices(indices, size);
-  }
-  void candidate(const tree t) {
-    proof prf;
-    listindices1(WK, t, prf); // assume WK odd
-    qsort(prf, PROOFSIZE, sizeof(u32), &compu32);
-    for (u32 i=1; i<PROOFSIZE; i++)
-      if (prf[i] <= prf[i-1])
-        return;
-#ifdef ATOMIC
-    u32 soli = std::atomic_fetch_add_explicit(&nsols, 1U, std::memory_order_relaxed);
-#else
-    u32 soli = nsols++;
-#endif
-    if (soli < MAXSOLS)
-      listindices1(WK, t, sols[soli]); // assume WK odd
-  }
-  void showbsizes(u32 r) {
-#if defined(HIST) || defined(SPARK)
-    u32 bsizes[NSLOTS+1];
-    memset(bsizes, 0, (NSLOTS+1) * sizeof(u32));
-    for (u32 bucketid = 0; bucketid < NBUCKETS; bucketid++) {
-      u32 bsize = nslots[r&1][bucketid];
-      if (bsize < NSLOTS)
-        bsizes[bsize]++;
-      else
-        bsizes[NSLOTS]++;
-    }
-    for (u32 i=0; i<=NSLOTS; i++) {
-#ifdef HIST
-      printf(" %d:%d", i, bsizes[i]);
-#else
-      printf("\342\226%c", '\201'+bsizes[i]/SPARKSCALE);
-#endif
-    }
-    printf("\n");
-#endif
-  }
-
-  struct htlayout {
-    htalloc hta;
-    u32 prevhashunits;
-    u32 nexthashunits;
-    u32 dunits;
-    u32 prevbo;
-    u32 nextbo;
-  
-    htlayout(equi *eq, u32 r): hta(eq->hta), prevhashunits(0), dunits(0) {
-      u32 nexthashbytes = hashsize(r);
-      nexthashunits = hashwords(nexthashbytes);
-      prevbo = 0;
-      nextbo = nexthashunits * sizeof(hashunit) - nexthashbytes; // 0-3
-      if (r) {
-        u32 prevhashbytes = hashsize(r-1);
-        prevhashunits = hashwords(prevhashbytes);
-        prevbo = prevhashunits * sizeof(hashunit) - prevhashbytes; // 0-3
-        dunits = prevhashunits - nexthashunits;
-      }
-    }
-    u32 getxhash0(const slot0* pslot) const {
-#ifdef XINTREE
-      return pslot->attr.xhash;
-#else
-      return pslot->hash.bytes[prevbo] >> 4;
-#endif
-    }
-    u32 getxhash1(const slot0* pslot) const {
-#ifdef XINTREE
-      return pslot->attr.xhash;
-#else
-      return pslot->hash.bytes[prevbo] & 0xf;
-#endif
-    }
-    bool equal(const hashunit *hash0, const hashunit *hash1) const {
-      return hash0[prevhashunits-1].word == hash1[prevhashunits-1].word;
-    }
-  };
-
-  struct collisiondata {
-#ifdef XBITMAP
-    u64 xhashmap[NRESTS];
-    u64 xmap;
-#else
-    typedef uchar xslot;
-    xslot nxhashslots[NRESTS];
-    xslot xhashslots[NRESTS][XFULL];
-    xslot *xx;
-    u32 n0;
-    u32 n1;
-#endif
-    u32 s0;
-
-    void clear() {
-#ifdef XBITMAP
-      memset(xhashmap, 0, NRESTS * sizeof(u64));
-#else
-      memset(nxhashslots, 0, NRESTS * sizeof(xslot));
-#endif
-    }
-    bool addslot(u32 s1, u32 xh) {
-#ifdef XBITMAP
-      xmap = xhashmap[xh];
-      xhashmap[xh] |= (u64)1 << s1;
-      s0 = -1;
-      return true;
-#else
-      n1 = (u32)nxhashslots[xh]++;
-      if (n1 >= XFULL)
-        return false;
-      xx = xhashslots[xh];
-      xx[n1] = s1;
-      n0 = 0;
-      return true;
-#endif
-    }
-    bool nextcollision() const {
-#ifdef XBITMAP
-      return xmap != 0;
-#else
-      return n0 < n1;
-#endif
-    }
-    u32 slot() {
-#ifdef XBITMAP
-      const u32 ffs = __builtin_ffsll(xmap);
-      s0 += ffs; xmap >>= ffs;
-      return s0;
-#else
-      return (u32)xx[n0++];
-#endif
-    }
-  };
-
-  void digit0(const u32 id) {
-    uchar hash[HASHOUT];
-    blake2b_state state;
-    htlayout htl(this, 0);
-    const u32 hashbytes = hashsize(0);
-    for (u32 block = id; block < NBLOCKS; block += nthreads) {
-      state = blake_ctx;
-      u32 leb = htole32(block);
-      blake2b_update(&state, (uchar *)&leb, sizeof(u32));
-      blake2b_final(&state, hash, HASHOUT);
-      for (u32 i = 0; i<HASHESPERBLAKE; i++) {
-        const uchar *ph = hash + i * WN/8;
-#if BUCKBITS == 16 && RESTBITS == 4
-        const u32 bucketid = ((u32)ph[0] << 8) | ph[1];
-#ifdef XINTREE
-        const u32 xhash = ph[2] >> 4;
-#endif
-#elif BUCKBITS == 20 && RESTBITS == 4
-        const u32 bucketid = ((((u32)ph[0] << 8) | ph[1]) << 4) | ph[2] >> 4;
-#ifdef XINTREE
-        const u32 xhash = ph[2] & 0xf;
-#endif
-#elif BUCKBITS == 12 && RESTBITS == 4
-        const u32 bucketid = ((u32)ph[0] << 4) | ph[1] >> 4;
-        const u32 xhash = ph[1] & 0xf;
-#else
-#error not implemented
-#endif
-        const u32 slot = getslot(0, bucketid);
-        if (slot >= NSLOTS) {
-          bfull++;
-          continue;
-        }
-        tree leaf;
-        leaf.setindex(block*HASHESPERBLAKE+i);
-#ifdef XINTREE
-        leaf.xhash = xhash;
-#endif
-        slot0 &s = hta.trees[0][bucketid][slot];
-        s.attr = leaf;
-        memcpy(s.hash->bytes+htl.nextbo, ph+WN/8-hashbytes, hashbytes);
-      }
-    }
-  }
-  
-  void digitodd(const u32 r, const u32 id) {
-    htlayout htl(this, r);
-    collisiondata cd;
-    for (u32 bucketid=id; bucketid < NBUCKETS; bucketid += nthreads) {
-      cd.clear();
-      slot0 *buck = htl.hta.trees[r-1][bucketid]; // optimize by updating previous buck?!
-      u32 bsize = getnslots(r-1, bucketid);       // optimize by putting bucketsize with block?!
-      for (u32 s1 = 0; s1 < bsize; s1++) {
-        const slot0 *pslot1 = buck + s1;          // optimize by updating previous pslot1?!
-        if (!cd.addslot(s1, htl.getxhash0(pslot1))) {
-          xfull++;
-          continue;
-        }
-        for (; cd.nextcollision(); ) {
-          const u32 s0 = cd.slot();
-          const slot0 *pslot0 = buck + s0;
-          if (htl.equal(pslot0->hash, pslot1->hash)) {
-            hfull++;
-            continue;
-          }
-          u32 xorbucketid;
-          u32 xhash;
-#if BUCKBITS == 16 && RESTBITS == 4
-#ifdef XINTREE
-          xorbucketid = ((u32)(pslot0->hash->bytes[htl.prevbo]^pslot1->hash->bytes[htl.prevbo]) << 8)
-            | (pslot0->hash->bytes[htl.prevbo+1]^pslot1->hash->bytes[htl.prevbo+1]);
-          xhash = pslot0->hash->bytes[htl.prevbo+2] ^ pslot1->hash->bytes[htl.prevbo+2];
-          xorbucketid = ((xorbucketid & 0xfff) << 4) | (xhash >> 4);
-          xhash &= 0xf;
-#else
-          xhash = hash0->bytes[htl.prevbo+2] ^ hash1->bytes[htl.prevbo+2];
-#error not yet implemented
-#endif
-#elif BUCKBITS == 20 && RESTBITS == 4 && !defined XINTREE
-          xhash = hash0->bytes[htl.prevbo+3] ^ hash1->bytes[htl.prevbo+3];
-          xorbucketid = ((((u32)(hash0->bytes[htl.prevbo+1]^hash1->bytes[htl.prevbo+1]) << 8) | (hash0->bytes[htl.prevbo+2]^hash1->bytes[htl.prevbo+2])) << 4) | xhash >> 4;
-          xhash &= 0xf;
-#elif BUCKBITS == 12 && RESTBITS == 4
-          xhash = hash0->bytes[htl.prevbo+1] ^ hash1->bytes[htl.prevbo+1];
-          xorbucketid = ((u32)(hash0->bytes[htl.prevbo]^hash1->bytes[htl.prevbo]) << 4) | xhash >> 4;
-          xhash &= 0xf;
-#else
-#error not implemented
-#endif
-          const u32 xorslot = getslot(r, xorbucketid);
-          if (xorslot >= NSLOTS) {
-            bfull++;
-            continue;
-          }
-          tree xort; xort.bucketid = bucketid;
-          xort.slotid0 = s0; xort.slotid1 = s1;
-#ifdef XINTREE
-          xort.xhash = xhash;
-#endif
-          slot0 &xs = htl.hta.trees[r][xorbucketid][xorslot];
-          xs.attr = xort;
-          for (u32 i=htl.dunits; i < htl.prevhashunits; i++)
-            xs.hash[i-htl.dunits].word = pslot0->hash[i].word ^ pslot1->hash[i].word;
-        }
-      }
-    }
-  }
-  
-  void digiteven(const u32 r, const u32 id) {
-    htlayout htl(this, r);
-    collisiondata cd;
-    for (u32 bucketid=id; bucketid < NBUCKETS; bucketid += nthreads) {
-      cd.clear();
-      slot0 *buck = htl.hta.trees[r-1][bucketid]; // optimize by updating previous buck?!
-      u32 bsize = getnslots(r-1, bucketid);       // optimize by putting bucketsize with block?!
-      for (u32 s1 = 0; s1 < bsize; s1++) {
-        const slot0 *pslot1 = buck + s1;          // optimize by updating previous pslot1?!
-        if (!cd.addslot(s1, htl.getxhash1(pslot1))) {
-          xfull++;
-          continue;
-        }
-        for (; cd.nextcollision(); ) {
-          const u32 s0 = cd.slot();
-          const slot0 *pslot0 = buck + s0;
-          if (htl.equal(pslot0->hash, pslot1->hash)) {
-            hfull++;
-            continue;
-          }
-          u32 xorbucketid;
-          u32 xhash;
-#if BUCKBITS == 16 && RESTBITS == 4
-#ifdef XINTREE
-          xorbucketid = ((u32)(pslot0->hash->bytes[htl.prevbo]^pslot1->hash->bytes[htl.prevbo]) << 8)
-            | (pslot0->hash->bytes[htl.prevbo+1]^pslot1->hash->bytes[htl.prevbo+1]);
-          xhash = (pslot0->hash->bytes[htl.prevbo+2] ^ pslot1->hash->bytes[htl.prevbo+2]) >> 4;
-#else
-          xhash = hash0->bytes[htl.prevbo+2] ^ hash1->bytes[htl.prevbo+2];
-#error not yet implemented
-#endif
-#elif BUCKBITS == 20 && RESTBITS == 4 && !defined XINTREE
-          xhash = hash0->bytes[htl.prevbo+3] ^ hash1->bytes[htl.prevbo+3];
-          xorbucketid = ((((u32)(hash0->bytes[htl.prevbo+1]^hash1->bytes[htl.prevbo+1]) << 8) | (hash0->bytes[htl.prevbo+2]^hash1->bytes[htl.prevbo+2])) << 4) | xhash >> 4;
-          xhash &= 0xf;
-#elif BUCKBITS == 12 && RESTBITS == 4
-          xhash = hash0->bytes[htl.prevbo+1] ^ hash1->bytes[htl.prevbo+1];
-          xorbucketid = ((u32)(hash0->bytes[htl.prevbo]^hash1->bytes[htl.prevbo]) << 4) | xhash >> 4;
-          xhash &= 0xf;
-#else
-#error not implemented
-#endif
-          const u32 xorslot = getslot(r, xorbucketid);
-          if (xorslot >= NSLOTS) {
-            bfull++;
-            continue;
-          }
-          tree xort; xort.bucketid = bucketid;
-          xort.slotid0 = s0; xort.slotid1 = s1;
-#ifdef XINTREE
-          xort.xhash = xhash;
-#endif
-          slot0 &xs = htl.hta.trees[r][xorbucketid][xorslot];
-          xs.attr = xort;
-          for (u32 i=htl.dunits; i < htl.prevhashunits; i++)
-            xs.hash[i-htl.dunits].word = pslot0->hash[i].word ^ pslot1->hash[i].word;
-        }
-      }
-    }
-  }
-  
-  void digitK(const u32 id) {
-    collisiondata cd;
-    htlayout htl(this, WK);
-    for (u32 bucketid = id; bucketid < NBUCKETS; bucketid += nthreads) {
-      cd.clear();
-      slot0 *buck = htl.hta.trees[WK-1][bucketid];
-      u32 bsize = getnslots(WK-1, bucketid);
-      for (u32 s1 = 0; s1 < bsize; s1++) {
-        const slot0 *pslot1 = buck + s1;
-        if (!cd.addslot(s1, htl.getxhash0(pslot1))) // assume WK odd
-          continue;
-        for (; cd.nextcollision(); ) {
-          const u32 s0 = cd.slot();
-          const slot0 *pslot0 = buck + s0;
-          if (htl.equal(pslot0->hash, pslot1->hash)) {
-            tree xort; xort.bucketid = bucketid;
-            xort.slotid0 = s0; xort.slotid1 = s1;
-            candidate(xort);
-          }
-        }
-      }
-    }
-  }
-};
-
-typedef struct {
-  u32 id;
-  pthread_t thread;
-  equi *eq;
-} thread_ctx;
-
-void barrier(pthread_barrier_t *barry) {
-  const int rc = pthread_barrier_wait(barry);
-  if (rc != 0 && rc != PTHREAD_BARRIER_SERIAL_THREAD) {
-    printf("Could not wait on barrier\n");
-    pthread_exit(NULL);
-  }
-}
-
-void *worker(void *vp) {
-  thread_ctx *tp = (thread_ctx *)vp;
-  equi *eq = tp->eq;
-
-  if (tp->id == 0)
-    printf("Digit 0\n");
-  barrier(&eq->barry);
-  eq->digit0(tp->id);
-  barrier(&eq->barry);
-  if (tp->id == 0) {
-    eq->xfull = eq->bfull = eq->hfull = 0;
-    eq->showbsizes(0);
-  }
-  barrier(&eq->barry);
-  for (u32 r = 1; r < WK; r++) {
-    if (tp->id == 0)
-      printf("Digit %d", r);
-    barrier(&eq->barry);
-    r&1 ? eq->digitodd(r, tp->id) : eq->digiteven(r, tp->id);
-    barrier(&eq->barry);
-    if (tp->id == 0) {
-      printf(" x%d b%d h%d\n", eq->xfull, eq->bfull, eq->hfull);
-      eq->xfull = eq->bfull = eq->hfull = 0;
-      eq->showbsizes(r);
-    }
-    barrier(&eq->barry);
-  }
-  if (tp->id == 0)
-    printf("Digit %d\n", WK);
-  eq->digitK(tp->id);
-  barrier(&eq->barry);
-  pthread_exit(NULL);
-  return 0;
-}