Initial progress on subsumption DFA. Why is this branch called subsumption-tree?

subtree.h

@@ -0,0 +1,89 @@
+#pragma once
+#include "types.h"
+#include <stdlib.h>
+
+
+
+/*
+void sortstrings(char** list, u32 len, u32 cnt) {
+    bool v = false;
+    u32* d = malloc(sizeof(u32) * c->litcnt);
+    u32* d2 = malloc(sizeof(u32) * c->litcnt);
+    u8* d3 = malloc(sizeof(u8) * c->litcnt);
+
+    u64 qb[RLVLS * RSIZE];
+    u64 qe[RLVLS * RSIZE];
+    memset(qb, 0, sizeof(u64) * RLVLS * RSIZE);
+    memset(qe, 0, sizeof(u64) * RLVLS * RSIZE);
+
+    for (u64 pass = 0; pass < RLVLS; ++pass) {
+        u64 shift = pass * RBITS;
+
+        for (u64 i = 0; i < N; ++i) {
+            // U32MAX - because we want to sort highest to lowest, not lowest to highest
+            u32 val = UINT32_MAX - c->lastvars[c->clauses[i]];
+            u64 ind = (val >> shift) & RMASK;
+            qe[pass * RSIZE + ind]++;
+        }
+
+        u64 uc = 0;
+        for (u64 i = 0; i < RSIZE; ++i) if (qe[pass * RSIZE + i]) uc++;
+        if (uc == 1) continue;
+
+        qb[pass * RSIZE] = 0;
+        for (u64 i = 1; i < RSIZE; ++i) {
+            qb[pass * RSIZE + i] = qb[pass * RSIZE + i - 1] + qe[pass * RSIZE + i - 1];
+        }
+
+        for (u64 i = 0; i < N; ++i) {
+            u32 val = UINT32_MAX - c->lastvars[c->clauses[i]];
+            u64 ind = (val >> shift) & RMASK;
+            d[qb[pass * RSIZE + ind]] = c->variables[i];
+            d2[qb[pass * RSIZE + ind]] = c->clauses[i];
+            d3[qb[pass * RSIZE + ind]] = c->pars[i];
+            qb[pass * RSIZE + ind]++;
+            __builtin_prefetch(d + qb[pass * RSIZE + ind] + 1);
+            __builtin_prefetch(d2 + qb[pass * RSIZE + ind] + 1);
+            __builtin_prefetch(d3 + qb[pass * RSIZE + ind] + 1);
+        }
+
+        // Every iteration we swap pointers to avoid doing a memcpy
+        u32* tptr = c->variables;
+        c->variables = d;
+        d = tptr;
+        tptr = c->clauses;
+        c->clauses = d2;
+        d2 = tptr;
+        u8* tptr2 = c->pars;
+        c->pars = d3;
+        d3 = tptr2;
+        v = !v;
+    }
+
+    // If the pointers are still swapped at the end, we swap them to their original locations and
+    // copy over the result
+    if (v) {
+        u32* tptr = c->variables;
+        c->variables = d;
+        d = tptr;
+        tptr = c->clauses;
+        c->clauses = d2;
+        d2 = tptr;
+        u8* tptr2 = c->pars;
+        c->pars = d3;
+        d3 = tptr2;
+        memcpy(c->variables, d, N * sizeof(u32));
+        memcpy(c->clauses, d2, N * sizeof(u32));
+        memcpy(c->pars, d3, N * sizeof(u8));
+    }
+    free(d);
+    free(d2);
+    free(d3);
+
+    // Initialize an array with all the clause indices in their current order
+    u32* swaparr = malloc(sizeof(u32) * c->clausecnt);
+    for (u32 i = 0; i < c->clausecnt; ++i) {
+        swaparr[i] = i;
+    }
+}
+ */