add files

Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>

src/sat/sat_cutset.cpp

@@ -0,0 +1,133 @@
+/*++
+  Copyright (c) 2020 Microsoft Corporation
+
+  Module Name:
+
+   sat_cutset.cpp
+
+  Author:
+
+    Nikolaj Bjorner 2020-01-02
+
+  --*/
+
+#pragma once;
+
+#include "util/hashtable.h"
+#include "sat/sat_cutset.h"
+#include "sat/sat_cutset_compute_shift.h"
+
+
+namespace sat {
+
+
+    /**
+       \brief
+       if c is subsumed by a member in cut_set, then c is not inserted.
+       otherwise, remove members that c subsumes.
+       Note that the cut_set maintains invariant that elements don't subsume each-other.
+       
+       TBD: this is a bottleneck.
+       Ideas:
+       - add Bloom filter to is_subset_of operation.
+       - pre-allocate fixed array instead of vector for cut_set to avoid overhead for memory allocation.
+    */
+    
+    void cut_set::insert(cut const& c) {
+        unsigned i = 0, j = 0;
+        for (; i < size(); ++i) {
+            cut const& a = (*this)[i];
+            if (a.subset_of(c)) {
+                return;
+            }
+            if (c.subset_of(a)) {
+                continue;
+            }
+            else if (j < i) {
+                (*this)[j] = a;
+            }
+            SASSERT(!(a == c));
+            ++j;
+        }
+        shrink(j);    
+        push_back(c);
+    }
+    
+    bool cut_set::no_duplicates() const {
+        hashtable<cut const*, cut::hash_proc, cut::eq_proc> table;
+        for (auto const& cut : *this) {
+            VERIFY(!table.contains(&cut));
+            table.insert(&cut);
+        }
+        return true;
+    }
+    
+    /**
+       \brief shift table 'a' by adding elements from 'c'.
+       a.shift_table(c)
+       
+       \pre 'a' is a subset of 'c'.
+       
+       Let 't' be the table for 'a'.
+       
+       i'th bit in t  is function of indices x0*2^0 + x2*2^1 = i
+       i'th bit in t' is function of indices x0*2^0 + x1*2^1 + x2*2^2 = i
+       
+       i -> assignment to coefficients in c, 
+       -> assignment to coefficients in a
+       -> compute j, 
+       -> t'[i] <- t[j]
+       
+       This is still time consuming:
+       Ideas: 
+       - pre-compute some shift operations.
+       - use strides on some common cases.
+       - what ABC does?
+    */
+    
+    
+    uint64_t cut::shift_table(cut const& c) const {
+        SASSERT(subset_of(c));
+        unsigned index = 0;
+        for (unsigned i = 0, j = 0, x = (*this)[i], y = c[j]; x != UINT_MAX; ) {
+            if (x == y) {
+                index |= (1 << j);
+                x = (*this)[++i];
+            }
+            y = c[++j];
+        }
+        index |= (1 << c.m_size);
+        return compute_shift(m_table, index);
+    }
+    
+    bool cut::operator==(cut const& other) const {
+        if (m_size != other.m_size) return false;
+        if (m_table != other.m_table) return false;
+        for (unsigned i = 0; i < m_size; ++i) {
+            if ((*this)[i] != other[i]) return false;
+        }
+        return true;
+    }
+    
+    unsigned cut::hash() const {
+        return get_composite_hash(*this, m_size, 
+                                  [](cut const& c) { return (unsigned)c.m_table; }, 
+                                  [](cut const& c, unsigned i) { return c[i]; });
+    }
+    
+    std::ostream& cut::display(std::ostream& out) const {
+        for (unsigned i = 0; i < m_size; ++i) {
+            out << (*this)[i] << " ";
+        }
+        out << "t: ";
+        for (unsigned i = 0; i < (1u << m_size); ++i) {
+            if (0 != (m_table & (1ull << i))) out << "1"; else out << "0";
+        }    
+        return out;
+    }
+
+    void cut::sort() {
+        std::sort(m_elems, m_elems + m_size);
+    }
+
+}

src/sat/sat_cutset.h

@@ -0,0 +1,127 @@
+
+#pragma once;
+#include "util/region.h"
+
+namespace sat {
+
+    struct cut {
+        static const unsigned max_cut_size = 6;
+        unsigned m_filter;
+        unsigned m_size;
+        unsigned m_elems[max_cut_size];
+        uint64_t m_table;
+        cut(): m_filter(0), m_size(0), m_table(0) {}
+
+        cut(unsigned id): m_filter(1u << (id & 0x1F)), m_size(1), m_table(2) { m_elems[0] = id; }
+
+        unsigned const* begin() const { return m_elems; }
+        unsigned const* end() const  { return m_elems + m_size; }
+
+        bool add(unsigned i, unsigned max_sz) {
+            SASSERT(max_sz <= max_cut_size);
+            if (m_size >= max_sz) {
+                return false;
+            }
+            else {
+                m_elems[m_size++] = i;
+                m_filter |= (1u << (i & 0x1F));
+                return true;
+            }
+        }
+        void sort();
+        void negate() { set_table(~m_table); }
+        void set_table(uint64_t t) { m_table = t & ((1ull << (1ull << m_size)) - 1ull); }
+
+        bool operator==(cut const& other) const;
+        unsigned hash() const;
+        struct eq_proc { 
+            bool operator()(cut const& a, cut const& b) const { return a == b; }
+            bool operator()(cut const* a, cut const* b) const { return *a == *b; }
+        };
+        struct hash_proc {
+            unsigned operator()(cut const& a) const { return a.hash(); }
+            unsigned operator()(cut const* a) const { return a->hash(); }
+        };
+
+        unsigned operator[](unsigned idx) const {
+            return (idx >= m_size) ? UINT_MAX : m_elems[idx];
+        }
+
+        uint64_t shift_table(cut const& other) const;
+
+        bool merge(cut const& a, cut const& b, unsigned max_cut_size) {
+            SASSERT(a.m_size > 0 && b.m_size > 0);
+            unsigned i = 0, j = 0;
+            unsigned x = a[i];
+            unsigned y = b[j];
+            while (x != UINT_MAX || y != UINT_MAX) {
+                if (!add(std::min(x, y), max_cut_size)) {
+                    return false;
+                }
+                if (x < y) {
+                    x = a[++i];
+                }
+                else if (y < x) {
+                    y = b[++j];
+                }
+                else {
+                    x = a[++i];
+                    y = b[++j];
+                }
+            }
+            return true;
+        }
+
+        bool subset_of(cut const& other) const {
+            if (other.m_filter != (m_filter | other.m_filter)) {
+                return false;
+            }
+            unsigned i = 0;
+            unsigned other_id = other[i];
+            for (unsigned id : *this) {
+                while (id > other_id) {
+                    other_id = other[++i];
+                }
+                if (id != other_id) return false;
+                other_id = other[++i];
+            }
+            return true;
+        }
+
+        std::ostream& display(std::ostream& out) const;
+    };
+
+    class cut_set {
+        region*  m_region;
+        unsigned m_size;
+        unsigned m_max_size;
+        cut *    m_cuts;
+    public:
+        cut_set(): m_region(nullptr), m_size(0), m_max_size(0), m_cuts(nullptr) {}
+        void init(region& r, unsigned sz) { 
+            m_region = &r; 
+            m_cuts = new (r) cut[sz]; 
+            m_max_size = sz; 
+        }
+        void insert(cut const& c);
+        bool no_duplicates() const;
+        unsigned size() const { return m_size; }
+        cut * begin() const { return m_cuts; }
+        cut * end() const { return m_cuts + m_size; }
+        cut & back() { return m_cuts[m_size-1]; }
+        void push_back(cut const& c) { 
+            if (m_size == m_max_size) {
+                m_max_size *= 2;
+                cut* new_cuts = new (*m_region) cut[m_max_size]; 
+                memcpy(new_cuts, m_cuts, sizeof(cut)*m_size);
+                m_cuts = new_cuts;
+            }
+            m_cuts[m_size++] = c; 
+        }
+        void reset() { m_size = 0; }
+        cut & operator[](unsigned idx) { return m_cuts[idx]; }
+        void shrink(unsigned j) { m_size = j; }
+        void swap(cut_set& other) { std::swap(m_size, other.m_size); std::swap(m_cuts, other.m_cuts); std::swap(m_max_size, other.m_max_size); }
+    };
+
+}

src/sat/sat_cutset_compute_shift.h

@@ -0,0 +1,917 @@
+static uint64_t compute_shift(uint64_t x, unsigned code) {
+    switch (code) {
+#define _x0 (x & 1)
+#define _x1 _x0
+    case 1: return _x1;
+#define _x2 (_x1 | (_x1 << 1))
+    case 2: return _x2;
+#define _x3 (x & 3)
+#define _x4 _x3
+    case 3: return _x4;
+#define _x5 (_x2 | (_x2 << 2))
+    case 4: return _x5;
+#define _x6 (_x4 | (_x4 << 2))
+    case 5: return _x6;
+#define _x7 (x & 2)
+#define _x8 (_x7 << 1)
+#define _x9 (_x8 | (_x8 << 1))
+#define _x10 (_x2 | _x9)
+    case 6: return _x10;
+#define _x11 (x & 15)
+#define _x12 _x11
+    case 7: return _x12;
+#define _x13 (_x5 | (_x5 << 4))
+    case 8: return _x13;
+#define _x14 (_x6 | (_x6 << 4))
+    case 9: return _x14;
+#define _x15 (_x10 | (_x10 << 4))
+    case 10: return _x15;
+#define _x16 (_x12 | (_x12 << 4))
+    case 11: return _x16;
+#define _x17 (_x7 << 3)
+#define _x18 (_x17 | (_x17 << 1))
+#define _x19 (_x18 | (_x18 << 2))
+#define _x20 (_x5 | _x19)
+    case 12: return _x20;
+#define _x21 (x & 12)
+#define _x22 (_x21 << 2)
+#define _x23 (_x22 | (_x22 << 2))
+#define _x24 (_x6 | _x23)
+    case 13: return _x24;
+#define _x25 (x & 4)
+#define _x26 (_x25 << 2)
+#define _x27 (_x26 | (_x26 << 1))
+#define _x28 (x & 8)
+#define _x29 (_x28 << 3)
+#define _x30 (_x29 | (_x29 << 1))
+#define _x31 (_x27 | _x30)
+#define _x32 (_x10 | _x31)
+    case 14: return _x32;
+#define _x33 (x & 255)
+#define _x34 _x33
+    case 15: return _x34;
+#define _x35 (_x13 | (_x13 << 8))
+    case 16: return _x35;
+#define _x36 (_x14 | (_x14 << 8))
+    case 17: return _x36;
+#define _x37 (_x15 | (_x15 << 8))
+    case 18: return _x37;
+#define _x38 (_x16 | (_x16 << 8))
+    case 19: return _x38;
+#define _x39 (_x20 | (_x20 << 8))
+    case 20: return _x39;
+#define _x40 (_x24 | (_x24 << 8))
+    case 21: return _x40;
+#define _x41 (_x32 | (_x32 << 8))
+    case 22: return _x41;
+#define _x42 (_x34 | (_x34 << 8))
+    case 23: return _x42;
+#define _x43 (_x7 << 7)
+#define _x44 (_x43 | (_x43 << 1))
+#define _x45 (_x44 | (_x44 << 2))
+#define _x46 (_x45 | (_x45 << 4))
+#define _x47 (_x13 | _x46)
+    case 24: return _x47;
+#define _x48 (_x21 << 6)
+#define _x49 (_x48 | (_x48 << 2))
+#define _x50 (_x49 | (_x49 << 4))
+#define _x51 (_x14 | _x50)
+    case 25: return _x51;
+#define _x52 (_x25 << 6)
+#define _x53 (_x52 | (_x52 << 1))
+#define _x54 (_x28 << 7)
+#define _x55 (_x54 | (_x54 << 1))
+#define _x56 (_x53 | _x55)
+#define _x57 (_x56 | (_x56 << 4))
+#define _x58 (_x15 | _x57)
+    case 26: return _x58;
+#define _x59 (x & 240)
+#define _x60 (_x59 << 4)
+#define _x61 (_x60 | (_x60 << 4))
+#define _x62 (_x16 | _x61)
+    case 27: return _x62;
+#define _x63 (_x53 | (_x53 << 2))
+#define _x64 (_x28 << 9)
+#define _x65 (_x64 | (_x64 << 1))
+#define _x66 (_x65 | (_x65 << 2))
+#define _x67 (_x63 | _x66)
+#define _x68 (_x20 | _x67)
+    case 28: return _x68;
+#define _x69 (x & 48)
+#define _x70 (_x69 << 4)
+#define _x71 (_x70 | (_x70 << 2))
+#define _x72 (x & 192)
+#define _x73 (_x72 << 6)
+#define _x74 (_x73 | (_x73 << 2))
+#define _x75 (_x71 | _x74)
+#define _x76 (_x24 | _x75)
+    case 29: return _x76;
+#define _x77 (x & 16)
+#define _x78 (_x77 << 4)
+#define _x79 (_x78 | (_x78 << 1))
+#define _x80 (x & 32)
+#define _x81 (_x80 << 5)
+#define _x82 (_x81 | (_x81 << 1))
+#define _x83 (_x79 | _x82)
+#define _x84 (x & 64)
+#define _x85 (_x84 << 6)
+#define _x86 (_x85 | (_x85 << 1))
+#define _x87 (x & 128)
+#define _x88 (_x87 << 7)
+#define _x89 (_x88 | (_x88 << 1))
+#define _x90 (_x86 | _x89)
+#define _x91 (_x83 | _x90)
+#define _x92 (_x32 | _x91)
+    case 30: return _x92;
+#define _x93 (x & 65535)
+#define _x94 _x93
+    case 31: return _x94;
+#define _x95 (_x35 | (_x35 << 16))
+    case 32: return _x95;
+#define _x96 (_x36 | (_x36 << 16))
+    case 33: return _x96;
+#define _x97 (_x37 | (_x37 << 16))
+    case 34: return _x97;
+#define _x98 (_x38 | (_x38 << 16))
+    case 35: return _x98;
+#define _x99 (_x39 | (_x39 << 16))
+    case 36: return _x99;
+#define _x100 (_x40 | (_x40 << 16))
+    case 37: return _x100;
+#define _x101 (_x41 | (_x41 << 16))
+    case 38: return _x101;
+#define _x102 (_x42 | (_x42 << 16))
+    case 39: return _x102;
+#define _x103 (_x47 | (_x47 << 16))
+    case 40: return _x103;
+#define _x104 (_x51 | (_x51 << 16))
+    case 41: return _x104;
+#define _x105 (_x58 | (_x58 << 16))
+    case 42: return _x105;
+#define _x106 (_x62 | (_x62 << 16))
+    case 43: return _x106;
+#define _x107 (_x68 | (_x68 << 16))
+    case 44: return _x107;
+#define _x108 (_x76 | (_x76 << 16))
+    case 45: return _x108;
+#define _x109 (_x92 | (_x92 << 16))
+    case 46: return _x109;
+#define _x110 (_x94 | (_x94 << 16))
+    case 47: return _x110;
+#define _x111 (_x7 << 15)
+#define _x112 (_x111 | (_x111 << 1))
+#define _x113 (_x112 | (_x112 << 2))
+#define _x114 (_x113 | (_x113 << 4))
+#define _x115 (_x114 | (_x114 << 8))
+#define _x116 (_x35 | _x115)
+    case 48: return _x116;
+#define _x117 (_x21 << 14)
+#define _x118 (_x117 | (_x117 << 2))
+#define _x119 (_x118 | (_x118 << 4))
+#define _x120 (_x119 | (_x119 << 8))
+#define _x121 (_x36 | _x120)
+    case 49: return _x121;
+#define _x122 (_x25 << 14)
+#define _x123 (_x122 | (_x122 << 1))
+#define _x124 (_x28 << 15)
+#define _x125 (_x124 | (_x124 << 1))
+#define _x126 (_x123 | _x125)
+#define _x127 (_x126 | (_x126 << 4))
+#define _x128 (_x127 | (_x127 << 8))
+#define _x129 (_x37 | _x128)
+    case 50: return _x129;
+#define _x130 (_x59 << 12)
+#define _x131 (_x130 | (_x130 << 4))
+#define _x132 (_x131 | (_x131 << 8))
+#define _x133 (_x38 | _x132)
+    case 51: return _x133;
+#define _x134 (_x123 | (_x123 << 2))
+#define _x135 (_x28 << 17)
+#define _x136 (_x135 | (_x135 << 1))
+#define _x137 (_x136 | (_x136 << 2))
+#define _x138 (_x134 | _x137)
+#define _x139 (_x138 | (_x138 << 8))
+#define _x140 (_x39 | _x139)
+    case 52: return _x140;
+#define _x141 (_x69 << 12)
+#define _x142 (_x141 | (_x141 << 2))
+#define _x143 (_x72 << 14)
+#define _x144 (_x143 | (_x143 << 2))
+#define _x145 (_x142 | _x144)
+#define _x146 (_x145 | (_x145 << 8))
+#define _x147 (_x40 | _x146)
+    case 53: return _x147;
+#define _x148 (_x77 << 12)
+#define _x149 (_x148 | (_x148 << 1))
+#define _x150 (_x80 << 13)
+#define _x151 (_x150 | (_x150 << 1))
+#define _x152 (_x149 | _x151)
+#define _x153 (_x84 << 14)
+#define _x154 (_x153 | (_x153 << 1))
+#define _x155 (_x87 << 15)
+#define _x156 (_x155 | (_x155 << 1))
+#define _x157 (_x154 | _x156)
+#define _x158 (_x152 | _x157)
+#define _x159 (_x158 | (_x158 << 8))
+#define _x160 (_x41 | _x159)
+    case 54: return _x160;
+#define _x161 (x & 65280)
+#define _x162 (_x161 << 8)
+#define _x163 (_x162 | (_x162 << 8))
+#define _x164 (_x42 | _x163)
+    case 55: return _x164;
+#define _x165 (_x134 | (_x134 << 4))
+#define _x166 (_x28 << 21)
+#define _x167 (_x166 | (_x166 << 1))
+#define _x168 (_x167 | (_x167 << 2))
+#define _x169 (_x168 | (_x168 << 4))
+#define _x170 (_x165 | _x169)
+#define _x171 (_x47 | _x170)
+    case 56: return _x171;
+#define _x172 (_x142 | (_x142 << 4))
+#define _x173 (_x72 << 18)
+#define _x174 (_x173 | (_x173 << 2))
+#define _x175 (_x174 | (_x174 << 4))
+#define _x176 (_x172 | _x175)
+#define _x177 (_x51 | _x176)
+    case 57: return _x177;
+#define _x178 (_x152 | (_x152 << 4))
+#define _x179 (_x84 << 18)
+#define _x180 (_x179 | (_x179 << 1))
+#define _x181 (_x87 << 19)
+#define _x182 (_x181 | (_x181 << 1))
+#define _x183 (_x180 | _x182)
+#define _x184 (_x183 | (_x183 << 4))
+#define _x185 (_x178 | _x184)
+#define _x186 (_x58 | _x185)
+    case 58: return _x186;
+#define _x187 (x & 3840)
+#define _x188 (_x187 << 8)
+#define _x189 (_x188 | (_x188 << 4))
+#define _x190 (x & 61440)
+#define _x191 (_x190 << 12)
+#define _x192 (_x191 | (_x191 << 4))
+#define _x193 (_x189 | _x192)
+#define _x194 (_x62 | _x193)
+    case 59: return _x194;
+#define _x195 (_x149 | (_x149 << 2))
+#define _x196 (_x80 << 15)
+#define _x197 (_x196 | (_x196 << 1))
+#define _x198 (_x197 | (_x197 << 2))
+#define _x199 (_x195 | _x198)
+#define _x200 (_x180 | (_x180 << 2))
+#define _x201 (_x87 << 21)
+#define _x202 (_x201 | (_x201 << 1))
+#define _x203 (_x202 | (_x202 << 2))
+#define _x204 (_x200 | _x203)
+#define _x205 (_x199 | _x204)
+#define _x206 (_x68 | _x205)
+    case 60: return _x206;
+#define _x207 (x & 768)
+#define _x208 (_x207 << 8)
+#define _x209 (_x208 | (_x208 << 2))
+#define _x210 (x & 3072)
+#define _x211 (_x210 << 10)
+#define _x212 (_x211 | (_x211 << 2))
+#define _x213 (_x209 | _x212)
+#define _x214 (x & 12288)
+#define _x215 (_x214 << 12)
+#define _x216 (_x215 | (_x215 << 2))
+#define _x217 (x & 49152)
+#define _x218 (_x217 << 14)
+#define _x219 (_x218 | (_x218 << 2))
+#define _x220 (_x216 | _x219)
+#define _x221 (_x213 | _x220)
+#define _x222 (_x76 | _x221)
+    case 61: return _x222;
+#define _x223 (x & 256)
+#define _x224 (_x223 << 8)
+#define _x225 (_x224 | (_x224 << 1))
+#define _x226 (x & 512)
+#define _x227 (_x226 << 9)
+#define _x228 (_x227 | (_x227 << 1))
+#define _x229 (_x225 | _x228)
+#define _x230 (x & 1024)
+#define _x231 (_x230 << 10)
+#define _x232 (_x231 | (_x231 << 1))
+#define _x233 (x & 2048)
+#define _x234 (_x233 << 11)
+#define _x235 (_x234 | (_x234 << 1))
+#define _x236 (_x232 | _x235)
+#define _x237 (_x229 | _x236)
+#define _x238 (x & 4096)
+#define _x239 (_x238 << 12)
+#define _x240 (_x239 | (_x239 << 1))
+#define _x241 (x & 8192)
+#define _x242 (_x241 << 13)
+#define _x243 (_x242 | (_x242 << 1))
+#define _x244 (_x240 | _x243)
+#define _x245 (x & 16384)
+#define _x246 (_x245 << 14)
+#define _x247 (_x246 | (_x246 << 1))
+#define _x248 (x & 32768)
+#define _x249 (_x248 << 15)
+#define _x250 (_x249 | (_x249 << 1))
+#define _x251 (_x247 | _x250)
+#define _x252 (_x244 | _x251)
+#define _x253 (_x237 | _x252)
+#define _x254 (_x92 | _x253)
+    case 62: return _x254;
+#define _x255 (x & 4294967295)
+#define _x256 _x255
+    case 63: return _x256;
+#define _x257 (_x95 | (_x95 << 32))
+    case 64: return _x257;
+#define _x258 (_x96 | (_x96 << 32))
+    case 65: return _x258;
+#define _x259 (_x97 | (_x97 << 32))
+    case 66: return _x259;
+#define _x260 (_x98 | (_x98 << 32))
+    case 67: return _x260;
+#define _x261 (_x99 | (_x99 << 32))
+    case 68: return _x261;
+#define _x262 (_x100 | (_x100 << 32))
+    case 69: return _x262;
+#define _x263 (_x101 | (_x101 << 32))
+    case 70: return _x263;
+#define _x264 (_x102 | (_x102 << 32))
+    case 71: return _x264;
+#define _x265 (_x103 | (_x103 << 32))
+    case 72: return _x265;
+#define _x266 (_x104 | (_x104 << 32))
+    case 73: return _x266;
+#define _x267 (_x105 | (_x105 << 32))
+    case 74: return _x267;
+#define _x268 (_x106 | (_x106 << 32))
+    case 75: return _x268;
+#define _x269 (_x107 | (_x107 << 32))
+    case 76: return _x269;
+#define _x270 (_x108 | (_x108 << 32))
+    case 77: return _x270;
+#define _x271 (_x109 | (_x109 << 32))
+    case 78: return _x271;
+#define _x272 (_x110 | (_x110 << 32))
+    case 79: return _x272;
+#define _x273 (_x116 | (_x116 << 32))
+    case 80: return _x273;
+#define _x274 (_x121 | (_x121 << 32))
+    case 81: return _x274;
+#define _x275 (_x129 | (_x129 << 32))
+    case 82: return _x275;
+#define _x276 (_x133 | (_x133 << 32))
+    case 83: return _x276;
+#define _x277 (_x140 | (_x140 << 32))
+    case 84: return _x277;
+#define _x278 (_x147 | (_x147 << 32))
+    case 85: return _x278;
+#define _x279 (_x160 | (_x160 << 32))
+    case 86: return _x279;
+#define _x280 (_x164 | (_x164 << 32))
+    case 87: return _x280;
+#define _x281 (_x171 | (_x171 << 32))
+    case 88: return _x281;
+#define _x282 (_x177 | (_x177 << 32))
+    case 89: return _x282;
+#define _x283 (_x186 | (_x186 << 32))
+    case 90: return _x283;
+#define _x284 (_x194 | (_x194 << 32))
+    case 91: return _x284;
+#define _x285 (_x206 | (_x206 << 32))
+    case 92: return _x285;
+#define _x286 (_x222 | (_x222 << 32))
+    case 93: return _x286;
+#define _x287 (_x254 | (_x254 << 32))
+    case 94: return _x287;
+#define _x288 (_x256 | (_x256 << 32))
+    case 95: return _x288;
+#define _x289 (_x7 << 31)
+#define _x290 (_x289 | (_x289 << 1))
+#define _x291 (_x290 | (_x290 << 2))
+#define _x292 (_x291 | (_x291 << 4))
+#define _x293 (_x292 | (_x292 << 8))
+#define _x294 (_x293 | (_x293 << 16))
+#define _x295 (_x95 | _x294)
+    case 96: return _x295;
+#define _x296 (_x21 << 30)
+#define _x297 (_x296 | (_x296 << 2))
+#define _x298 (_x297 | (_x297 << 4))
+#define _x299 (_x298 | (_x298 << 8))
+#define _x300 (_x299 | (_x299 << 16))
+#define _x301 (_x96 | _x300)
+    case 97: return _x301;
+#define _x302 (_x25 << 30)
+#define _x303 (_x302 | (_x302 << 1))
+#define _x304 (_x28 << 31)
+#define _x305 (_x304 | (_x304 << 1))
+#define _x306 (_x303 | _x305)
+#define _x307 (_x306 | (_x306 << 4))
+#define _x308 (_x307 | (_x307 << 8))
+#define _x309 (_x308 | (_x308 << 16))
+#define _x310 (_x97 | _x309)
+    case 98: return _x310;
+#define _x311 (_x59 << 28)
+#define _x312 (_x311 | (_x311 << 4))
+#define _x313 (_x312 | (_x312 << 8))
+#define _x314 (_x313 | (_x313 << 16))
+#define _x315 (_x98 | _x314)
+    case 99: return _x315;
+#define _x316 (_x303 | (_x303 << 2))
+#define _x317 (_x28 << 33)
+#define _x318 (_x317 | (_x317 << 1))
+#define _x319 (_x318 | (_x318 << 2))
+#define _x320 (_x316 | _x319)
+#define _x321 (_x320 | (_x320 << 8))
+#define _x322 (_x321 | (_x321 << 16))
+#define _x323 (_x99 | _x322)
+    case 100: return _x323;
+#define _x324 (_x69 << 28)
+#define _x325 (_x324 | (_x324 << 2))
+#define _x326 (_x72 << 30)
+#define _x327 (_x326 | (_x326 << 2))
+#define _x328 (_x325 | _x327)
+#define _x329 (_x328 | (_x328 << 8))
+#define _x330 (_x329 | (_x329 << 16))
+#define _x331 (_x100 | _x330)
+    case 101: return _x331;
+#define _x332 (_x77 << 28)
+#define _x333 (_x332 | (_x332 << 1))
+#define _x334 (_x80 << 29)
+#define _x335 (_x334 | (_x334 << 1))
+#define _x336 (_x333 | _x335)
+#define _x337 (_x84 << 30)
+#define _x338 (_x337 | (_x337 << 1))
+#define _x339 (_x87 << 31)
+#define _x340 (_x339 | (_x339 << 1))
+#define _x341 (_x338 | _x340)
+#define _x342 (_x336 | _x341)
+#define _x343 (_x342 | (_x342 << 8))
+#define _x344 (_x343 | (_x343 << 16))
+#define _x345 (_x101 | _x344)
+    case 102: return _x345;
+#define _x346 (_x161 << 24)
+#define _x347 (_x346 | (_x346 << 8))
+#define _x348 (_x347 | (_x347 << 16))
+#define _x349 (_x102 | _x348)
+    case 103: return _x349;
+#define _x350 (_x316 | (_x316 << 4))
+#define _x351 (_x28 << 37)
+#define _x352 (_x351 | (_x351 << 1))
+#define _x353 (_x352 | (_x352 << 2))
+#define _x354 (_x353 | (_x353 << 4))
+#define _x355 (_x350 | _x354)
+#define _x356 (_x355 | (_x355 << 16))
+#define _x357 (_x103 | _x356)
+    case 104: return _x357;
+#define _x358 (_x325 | (_x325 << 4))
+#define _x359 (_x72 << 34)
+#define _x360 (_x359 | (_x359 << 2))
+#define _x361 (_x360 | (_x360 << 4))
+#define _x362 (_x358 | _x361)
+#define _x363 (_x362 | (_x362 << 16))
+#define _x364 (_x104 | _x363)
+    case 105: return _x364;
+#define _x365 (_x336 | (_x336 << 4))
+#define _x366 (_x84 << 34)
+#define _x367 (_x366 | (_x366 << 1))
+#define _x368 (_x87 << 35)
+#define _x369 (_x368 | (_x368 << 1))
+#define _x370 (_x367 | _x369)
+#define _x371 (_x370 | (_x370 << 4))
+#define _x372 (_x365 | _x371)
+#define _x373 (_x372 | (_x372 << 16))
+#define _x374 (_x105 | _x373)
+    case 106: return _x374;
+#define _x375 (_x187 << 24)
+#define _x376 (_x375 | (_x375 << 4))
+#define _x377 (_x190 << 28)
+#define _x378 (_x377 | (_x377 << 4))
+#define _x379 (_x376 | _x378)
+#define _x380 (_x379 | (_x379 << 16))
+#define _x381 (_x106 | _x380)
+    case 107: return _x381;
+#define _x382 (_x333 | (_x333 << 2))
+#define _x383 (_x80 << 31)
+#define _x384 (_x383 | (_x383 << 1))
+#define _x385 (_x384 | (_x384 << 2))
+#define _x386 (_x382 | _x385)
+#define _x387 (_x367 | (_x367 << 2))
+#define _x388 (_x87 << 37)
+#define _x389 (_x388 | (_x388 << 1))
+#define _x390 (_x389 | (_x389 << 2))
+#define _x391 (_x387 | _x390)
+#define _x392 (_x386 | _x391)
+#define _x393 (_x392 | (_x392 << 16))
+#define _x394 (_x107 | _x393)
+    case 108: return _x394;
+#define _x395 (_x207 << 24)
+#define _x396 (_x395 | (_x395 << 2))
+#define _x397 (_x210 << 26)
+#define _x398 (_x397 | (_x397 << 2))
+#define _x399 (_x396 | _x398)
+#define _x400 (_x214 << 28)
+#define _x401 (_x400 | (_x400 << 2))
+#define _x402 (_x217 << 30)
+#define _x403 (_x402 | (_x402 << 2))
+#define _x404 (_x401 | _x403)
+#define _x405 (_x399 | _x404)
+#define _x406 (_x405 | (_x405 << 16))
+#define _x407 (_x108 | _x406)
+    case 109: return _x407;
+#define _x408 (_x223 << 24)
+#define _x409 (_x408 | (_x408 << 1))
+#define _x410 (_x226 << 25)
+#define _x411 (_x410 | (_x410 << 1))
+#define _x412 (_x409 | _x411)
+#define _x413 (_x230 << 26)
+#define _x414 (_x413 | (_x413 << 1))
+#define _x415 (_x233 << 27)
+#define _x416 (_x415 | (_x415 << 1))
+#define _x417 (_x414 | _x416)
+#define _x418 (_x412 | _x417)
+#define _x419 (_x238 << 28)
+#define _x420 (_x419 | (_x419 << 1))
+#define _x421 (_x241 << 29)
+#define _x422 (_x421 | (_x421 << 1))
+#define _x423 (_x420 | _x422)
+#define _x424 (_x245 << 30)
+#define _x425 (_x424 | (_x424 << 1))
+#define _x426 (_x248 << 31)
+#define _x427 (_x426 | (_x426 << 1))
+#define _x428 (_x425 | _x427)
+#define _x429 (_x423 | _x428)
+#define _x430 (_x418 | _x429)
+#define _x431 (_x430 | (_x430 << 16))
+#define _x432 (_x109 | _x431)
+    case 110: return _x432;
+#define _x433 (x & 4294901760)
+#define _x434 (_x433 << 16)
+#define _x435 (_x434 | (_x434 << 16))
+#define _x436 (_x110 | _x435)
+    case 111: return _x436;
+#define _x437 (_x350 | (_x350 << 8))
+#define _x438 (_x28 << 45)
+#define _x439 (_x438 | (_x438 << 1))
+#define _x440 (_x439 | (_x439 << 2))
+#define _x441 (_x440 | (_x440 << 4))
+#define _x442 (_x441 | (_x441 << 8))
+#define _x443 (_x437 | _x442)
+#define _x444 (_x116 | _x443)
+    case 112: return _x444;
+#define _x445 (_x358 | (_x358 << 8))
+#define _x446 (_x72 << 42)
+#define _x447 (_x446 | (_x446 << 2))
+#define _x448 (_x447 | (_x447 << 4))
+#define _x449 (_x448 | (_x448 << 8))
+#define _x450 (_x445 | _x449)
+#define _x451 (_x121 | _x450)
+    case 113: return _x451;
+#define _x452 (_x365 | (_x365 << 8))
+#define _x453 (_x84 << 42)
+#define _x454 (_x453 | (_x453 << 1))
+#define _x455 (_x87 << 43)
+#define _x456 (_x455 | (_x455 << 1))
+#define _x457 (_x454 | _x456)
+#define _x458 (_x457 | (_x457 << 4))
+#define _x459 (_x458 | (_x458 << 8))
+#define _x460 (_x452 | _x459)
+#define _x461 (_x129 | _x460)
+    case 114: return _x461;
+#define _x462 (_x376 | (_x376 << 8))
+#define _x463 (_x190 << 36)
+#define _x464 (_x463 | (_x463 << 4))
+#define _x465 (_x464 | (_x464 << 8))
+#define _x466 (_x462 | _x465)
+#define _x467 (_x133 | _x466)
+    case 115: return _x467;
+#define _x468 (_x386 | (_x386 << 8))
+#define _x469 (_x454 | (_x454 << 2))
+#define _x470 (_x87 << 45)
+#define _x471 (_x470 | (_x470 << 1))
+#define _x472 (_x471 | (_x471 << 2))
+#define _x473 (_x469 | _x472)
+#define _x474 (_x473 | (_x473 << 8))
+#define _x475 (_x468 | _x474)
+#define _x476 (_x140 | _x475)
+    case 116: return _x476;
+#define _x477 (_x399 | (_x399 << 8))
+#define _x478 (_x214 << 36)
+#define _x479 (_x478 | (_x478 << 2))
+#define _x480 (_x217 << 38)
+#define _x481 (_x480 | (_x480 << 2))
+#define _x482 (_x479 | _x481)
+#define _x483 (_x482 | (_x482 << 8))
+#define _x484 (_x477 | _x483)
+#define _x485 (_x147 | _x484)
+    case 117: return _x485;
+#define _x486 (_x418 | (_x418 << 8))
+#define _x487 (_x238 << 36)
+#define _x488 (_x487 | (_x487 << 1))
+#define _x489 (_x241 << 37)
+#define _x490 (_x489 | (_x489 << 1))
+#define _x491 (_x488 | _x490)
+#define _x492 (_x245 << 38)
+#define _x493 (_x492 | (_x492 << 1))
+#define _x494 (_x248 << 39)
+#define _x495 (_x494 | (_x494 << 1))
+#define _x496 (_x493 | _x495)
+#define _x497 (_x491 | _x496)
+#define _x498 (_x497 | (_x497 << 8))
+#define _x499 (_x486 | _x498)
+#define _x500 (_x160 | _x499)
+    case 118: return _x500;
+#define _x501 (x & 16711680)
+#define _x502 (_x501 << 16)
+#define _x503 (_x502 | (_x502 << 8))
+#define _x504 (x & 4278190080)
+#define _x505 (_x504 << 24)
+#define _x506 (_x505 | (_x505 << 8))
+#define _x507 (_x503 | _x506)
+#define _x508 (_x164 | _x507)
+    case 119: return _x508;
+#define _x509 (_x382 | (_x382 << 4))
+#define _x510 (_x80 << 35)
+#define _x511 (_x510 | (_x510 << 1))
+#define _x512 (_x511 | (_x511 << 2))
+#define _x513 (_x512 | (_x512 << 4))
+#define _x514 (_x509 | _x513)
+#define _x515 (_x469 | (_x469 << 4))
+#define _x516 (_x87 << 49)
+#define _x517 (_x516 | (_x516 << 1))
+#define _x518 (_x517 | (_x517 << 2))
+#define _x519 (_x518 | (_x518 << 4))
+#define _x520 (_x515 | _x519)
+#define _x521 (_x514 | _x520)
+#define _x522 (_x171 | _x521)
+    case 120: return _x522;
+#define _x523 (_x396 | (_x396 << 4))
+#define _x524 (_x210 << 30)
+#define _x525 (_x524 | (_x524 << 2))
+#define _x526 (_x525 | (_x525 << 4))
+#define _x527 (_x523 | _x526)
+#define _x528 (_x479 | (_x479 << 4))
+#define _x529 (_x217 << 42)
+#define _x530 (_x529 | (_x529 << 2))
+#define _x531 (_x530 | (_x530 << 4))
+#define _x532 (_x528 | _x531)
+#define _x533 (_x527 | _x532)
+#define _x534 (_x177 | _x533)
+    case 121: return _x534;
+#define _x535 (_x412 | (_x412 << 4))
+#define _x536 (_x230 << 30)
+#define _x537 (_x536 | (_x536 << 1))
+#define _x538 (_x233 << 31)
+#define _x539 (_x538 | (_x538 << 1))
+#define _x540 (_x537 | _x539)
+#define _x541 (_x540 | (_x540 << 4))
+#define _x542 (_x535 | _x541)
+#define _x543 (_x491 | (_x491 << 4))
+#define _x544 (_x245 << 42)
+#define _x545 (_x544 | (_x544 << 1))
+#define _x546 (_x248 << 43)
+#define _x547 (_x546 | (_x546 << 1))
+#define _x548 (_x545 | _x547)
+#define _x549 (_x548 | (_x548 << 4))
+#define _x550 (_x543 | _x549)
+#define _x551 (_x542 | _x550)
+#define _x552 (_x186 | _x551)
+    case 122: return _x552;
+#define _x553 (x & 983040)
+#define _x554 (_x553 << 16)
+#define _x555 (_x554 | (_x554 << 4))
+#define _x556 (x & 15728640)
+#define _x557 (_x556 << 20)
+#define _x558 (_x557 | (_x557 << 4))
+#define _x559 (_x555 | _x558)
+#define _x560 (x & 251658240)
+#define _x561 (_x560 << 24)
+#define _x562 (_x561 | (_x561 << 4))
+#define _x563 (x & 4026531840)
+#define _x564 (_x563 << 28)
+#define _x565 (_x564 | (_x564 << 4))
+#define _x566 (_x562 | _x565)
+#define _x567 (_x559 | _x566)
+#define _x568 (_x194 | _x567)
+    case 123: return _x568;
+#define _x569 (_x409 | (_x409 << 2))
+#define _x570 (_x226 << 27)
+#define _x571 (_x570 | (_x570 << 1))
+#define _x572 (_x571 | (_x571 << 2))
+#define _x573 (_x569 | _x572)
+#define _x574 (_x537 | (_x537 << 2))
+#define _x575 (_x233 << 33)
+#define _x576 (_x575 | (_x575 << 1))
+#define _x577 (_x576 | (_x576 << 2))
+#define _x578 (_x574 | _x577)
+#define _x579 (_x573 | _x578)
+#define _x580 (_x488 | (_x488 << 2))
+#define _x581 (_x241 << 39)
+#define _x582 (_x581 | (_x581 << 1))
+#define _x583 (_x582 | (_x582 << 2))
+#define _x584 (_x580 | _x583)
+#define _x585 (_x545 | (_x545 << 2))
+#define _x586 (_x248 << 45)
+#define _x587 (_x586 | (_x586 << 1))
+#define _x588 (_x587 | (_x587 << 2))
+#define _x589 (_x585 | _x588)
+#define _x590 (_x584 | _x589)
+#define _x591 (_x579 | _x590)
+#define _x592 (_x206 | _x591)
+    case 124: return _x592;
+#define _x593 (x & 196608)
+#define _x594 (_x593 << 16)
+#define _x595 (_x594 | (_x594 << 2))
+#define _x596 (x & 786432)
+#define _x597 (_x596 << 18)
+#define _x598 (_x597 | (_x597 << 2))
+#define _x599 (_x595 | _x598)
+#define _x600 (x & 3145728)
+#define _x601 (_x600 << 20)
+#define _x602 (_x601 | (_x601 << 2))
+#define _x603 (x & 12582912)
+#define _x604 (_x603 << 22)
+#define _x605 (_x604 | (_x604 << 2))
+#define _x606 (_x602 | _x605)
+#define _x607 (_x599 | _x606)
+#define _x608 (x & 50331648)
+#define _x609 (_x608 << 24)
+#define _x610 (_x609 | (_x609 << 2))
+#define _x611 (x & 201326592)
+#define _x612 (_x611 << 26)
+#define _x613 (_x612 | (_x612 << 2))
+#define _x614 (_x610 | _x613)
+#define _x615 (x & 805306368)
+#define _x616 (_x615 << 28)
+#define _x617 (_x616 | (_x616 << 2))
+#define _x618 (x & 3221225472)
+#define _x619 (_x618 << 30)
+#define _x620 (_x619 | (_x619 << 2))
+#define _x621 (_x617 | _x620)
+#define _x622 (_x614 | _x621)
+#define _x623 (_x607 | _x622)
+#define _x624 (_x222 | _x623)
+    case 125: return _x624;
+#define _x625 (x & 65536)
+#define _x626 (_x625 << 16)
+#define _x627 (_x626 | (_x626 << 1))
+#define _x628 (x & 131072)
+#define _x629 (_x628 << 17)
+#define _x630 (_x629 | (_x629 << 1))
+#define _x631 (_x627 | _x630)
+#define _x632 (x & 262144)
+#define _x633 (_x632 << 18)
+#define _x634 (_x633 | (_x633 << 1))
+#define _x635 (x & 524288)
+#define _x636 (_x635 << 19)
+#define _x637 (_x636 | (_x636 << 1))
+#define _x638 (_x634 | _x637)
+#define _x639 (_x631 | _x638)
+#define _x640 (x & 1048576)
+#define _x641 (_x640 << 20)
+#define _x642 (_x641 | (_x641 << 1))
+#define _x643 (x & 2097152)
+#define _x644 (_x643 << 21)
+#define _x645 (_x644 | (_x644 << 1))
+#define _x646 (_x642 | _x645)
+#define _x647 (x & 4194304)
+#define _x648 (_x647 << 22)
+#define _x649 (_x648 | (_x648 << 1))
+#define _x650 (x & 8388608)
+#define _x651 (_x650 << 23)
+#define _x652 (_x651 | (_x651 << 1))
+#define _x653 (_x649 | _x652)
+#define _x654 (_x646 | _x653)
+#define _x655 (_x639 | _x654)
+#define _x656 (x & 16777216)
+#define _x657 (_x656 << 24)
+#define _x658 (_x657 | (_x657 << 1))
+#define _x659 (x & 33554432)
+#define _x660 (_x659 << 25)
+#define _x661 (_x660 | (_x660 << 1))
+#define _x662 (_x658 | _x661)
+#define _x663 (x & 67108864)
+#define _x664 (_x663 << 26)
+#define _x665 (_x664 | (_x664 << 1))
+#define _x666 (x & 134217728)
+#define _x667 (_x666 << 27)
+#define _x668 (_x667 | (_x667 << 1))
+#define _x669 (_x665 | _x668)
+#define _x670 (_x662 | _x669)
+#define _x671 (x & 268435456)
+#define _x672 (_x671 << 28)
+#define _x673 (_x672 | (_x672 << 1))
+#define _x674 (x & 536870912)
+#define _x675 (_x674 << 29)
+#define _x676 (_x675 | (_x675 << 1))
+#define _x677 (_x673 | _x676)
+#define _x678 (x & 1073741824)
+#define _x679 (_x678 << 30)
+#define _x680 (_x679 | (_x679 << 1))
+#define _x681 (x & 2147483648)
+#define _x682 (_x681 << 31)
+#define _x683 (_x682 | (_x682 << 1))
+#define _x684 (_x680 | _x683)
+#define _x685 (_x677 | _x684)
+#define _x686 (_x670 | _x685)
+#define _x687 (_x655 | _x686)
+#define _x688 (_x254 | _x687)
+    case 126: return _x688;
+    case 127: return x;
+    default:
+        UNREACHABLE();
+        return 0;
+    }
+}
+
+
+#if 0
+
+def consecutive(S):
+    for k in range(len(S)-1):
+        if S[k] + 1 != S[k+1]:
+            return False
+    return True
+
+def shift(x, k):
+    if k == 0:
+        return x
+    if k < 0:
+        return "(%s >> %d)" % (x,-k)
+    return "(%s << %d)" % (x, k)
+
+def hash(r, hashcons):
+    if r in hashcons:
+        return hashcons[r]
+    id = "_x%d" % len(hashcons)
+    print ("#define %s %s" % (id, r))
+    hashcons[r] = id
+    return id
+
+def compile(S, offset, hashcons):
+    if consecutive(S):
+        k = S[0]
+        l = len(S)
+        if l == 64:
+            return "x"
+        mask = ((1 << l)-1) << k
+        return hash(shift(hash("(x & %d)" % mask, hashcons), offset - k), hashcons)
+    l2 = len(S) >> 1
+    S1 = S[0:l2]
+    S2 = S[l2:]
+    if S1 == S2:
+        r1 = compile(S1, offset, hashcons)        
+        return hash("(%s | (%s << %d))" % (r1, r1, l2), hashcons)
+    r1 = compile(S1, offset, hashcons)
+    r2 = compile(S2, offset + l2, hashcons)
+    return hash("(%s | %s)" % (r1, r2), hashcons)
+
+def mems2index(mems, bound):
+    k = 0
+    i = 0
+    for m in mems:
+        if m:
+            k |= (1 << i)
+        i += 1
+    k |= (1 << i)
+    return k
+
+def precompute(mems, bound, hashcons):
+    K = 0
+    j = 0
+    coeff = {}
+    deficit = {}
+    for m in mems:
+        if m:
+            coeff[K] = (1 << j)
+            deficit[K] = j - K
+            K += 1
+        j += 1
+    indices = []
+    for j in range(1 << len(mems)):
+        k = 0
+        for i in range(K):
+            if 0 != (j & coeff[i]):
+                k += (1 << i)
+        indices += [k]
+    idx = mems2index(mems, bound)
+    instr = compile(indices, 0, hashcons)
+    print("    case %d: return %s;" % (idx, instr))
+
+def create_mems(mems, n):
+    if n == 0:
+        return ([], mems)
+    prefix, m1 = create_mems(mems, n - 1)
+    m2 = [m + [False] for m in m1]
+    m3 = [m + [True] for m in m1]
+    return prefix + m1, m2 + m3
+
+def combinations(n, m, hashcons):
+    prefix, S = create_mems([[]], 6)
+    mems = prefix + S
+    for mem in mems:
+        precompute(mem, m, hashcons)
+
+hashcons = {}
+combinations(7, 7, hashcons)
+        
+#endif
+