react-native-quick-crypto 1.0.19 → 1.1.0

package/deps/simdutf/scripts/base64/neon_decode.py

@@ -0,0 +1,143 @@
+t='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+spaces=' \t\n\r\f'
+lut_lo = [0x3a, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x61, 0xe1, 0xb4, 0xe5, 0xe5, 0xf4, 0xb4]
+lut_hi = [0x11, 0x20, 0x42, 0x80, 0x8,  0x4,  0x8,  0x4, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20]
+roll = [0x0, 0x10, 0x13, 0x4, 0xbf, 0xbf, 0xb9, 0xb9, 0x0, 0x0,  0x0,  0x0, 0x0,  0x0,  0x0,  0x0]
+def decode(s):
+    low = s & 0xf
+    high = s >> 4
+    m = lut_lo[low] & lut_hi[high]
+    if(m > 0x3):
+        return (m, None)
+    if s == 0x2f:
+        off = roll[high - 1]
+    else:
+        off = roll[high]
+    return (m,(s + off)&0xff)
+
+
+for i in range(256):
+    m,d = decode(i)
+    if d is None:
+        assert t.find(chr(i)) == -1
+        assert spaces.find(chr(i)) == -1
+        continue
+    if m == 0:
+        assert d >= 0
+        # we must have a base64 element
+        v = t.find(chr(i))
+        assert v == d
+    else:
+        # we must have a space
+        v = spaces.find(chr(i))
+        assert v >= 0, (i, chr(i), v)
+print("REGULAR")
+print("lut_lo")
+print(",".join([hex(c) for c in lut_lo]))
+print("lut_hi")
+print(",".join([hex(c) for c in lut_hi]))
+print("roll")
+print(",".join([hex(c) for c in roll]))
+
+
+print("SWITCHING TO BASE64URL")
+print()
+t='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'
+spaces=' \t\n\r\f'
+
+lut_lo = [0x3a, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x61, 0xe1, 0xb4, 0xf4, 0xe5, 0xf4, 0xb0]
+lut_hi = [0x11, 0x20, 0x42, 0x80, 0x8,  0x4,  0x8,  0x4, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20]
+roll = [0xe0, 0x11, 0x13, 0x4, 0xbf, 0xbf, 0xb9, 0xb9, 0x0, 0x0,  0x0,  0x0, 0x0,  0x0,  0x0,  0x0]
+t='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'
+spaces=' \t\n\r\f' ## ['0x20', '0x9', '0xa', '0xd']
+
+
+lut_lo = [0x0 for i in range(16)]
+lut_hi = [0x0 for i in range(16)]
+#roll = [0 for i in range(16)]
+
+#0x00 are forbidden except for \t \n \r \f which go to one
+lut_hi[0] = 0x11
+for z in range(16):
+    if '\t\n\r\f'.find(chr(z)) != -1:
+        lut_lo[z & 0xf] = 0x1 # allowed
+    else:
+        lut_lo[z] = 0x10 # forbidden
+#0x10 and 0x80 all forbidden
+lut_hi[0x1] = 0x20
+for z in range(0x8, 16):
+    lut_hi[z] = 0x20
+#lut_hi[0x8] = 0x20
+
+for z in range(16):
+    lut_lo[z] |= 0x20
+
+#0x20 selective
+lut_hi[0x2] = 0x42
+for z in range(16):
+    if z == 0:
+        lut_lo[z] |= 0x2
+    elif z != 0xd:
+        lut_lo[z] |= 0x40
+
+
+#0x30 numbers
+lut_hi[0x3] = 0x80
+for z in range(10,16):
+    lut_lo[z] |= 0x80
+
+#0x40, 0x60 letters
+lut_hi[0x4] = 0x8
+lut_hi[0x6] = 0x8
+lut_lo[0] |= 0x8
+
+#0x7 letters
+#0x5 letters
+lut_hi[0x5] |= 0x4
+lut_hi[0x7] |= 0x4
+for i in range(0xb,16):
+    lut_lo[i] |= 0x4
+
+
+
+def decodes(s):
+    low = s & 0xf
+    high = s >> 4
+    m = lut_lo[low] & lut_hi[high]
+    is_underscore = s == 0x5f
+    if(is_underscore):
+        m = 0
+        high = 0
+    if(m > 0x3):
+        return (m, None)
+    if s == 0x2d:
+        off = roll[high - 1]
+    else:
+        off = roll[high]
+    return (m,(s + off)&0xff)
+print("lut_lo")
+print(",".join([hex(c) for c in lut_lo]))
+print("lut_hi")
+print(",".join([hex(c) for c in lut_hi]))
+print("roll")
+print(",".join([hex(c) for c in roll]))
+
+
+for i in range(256):
+    m,d = decodes(i)
+    if d is None:
+        assert t.find(chr(i)) == -1
+        assert spaces.find(chr(i)) == -1
+        continue
+    if m == 0:
+        assert d >= 0
+        # we must have a base64 element
+        v = t.find(chr(i))
+        if(v != d): 
+            print(hex(i), chr(i), v, d)
+        #assert v == d
+    else:
+        # we must have a space
+        v = spaces.find(chr(i))
+        assert v >= 0, (i, chr(i), v)
+

package/deps/simdutf/scripts/base64/neon_generate_lut.py

@@ -0,0 +1,101 @@
+lut_lo = [0x0 for _ in range(16)]
+lut_hi = [0x0 for _ in range(16)]
+
+# uses (c & 0xf) for indexing lut_lo
+# uses ((c >> 3) & 0xf) for indexing lut_hi
+# bytes with c > 127 will have lut_hi mapped to 0 via vtbl1q_u8
+
+# represent spaces by 0x1
+# represent + (_) by 0x2
+# represent / (-) by 0x4
+# represent numbers by 0x8
+# represent the partial row of upper alphabets with 0x10
+# represent full valid row of upper alphabets with 0x20
+# represent the partial row of lower alphabets with 0x40
+# represent full valid row of lower alphabets with 0x80
+# since '@' and 'P' both map to same lut_lo[0], use two different bits to separate them
+lut_hi[0] = 0x0  # ['\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07']
+lut_hi[1] = (
+    0x1  # can have spaces ['\x08', '\t', '\n', '\x0b', '\x0c', '\r', '\x0e', '\x0f']
+)
+for z in range(16):
+    if "\t\n\r\f".find(chr(z)) != -1:
+        lut_lo[z & 0xF] = 0x1  # allowed
+
+# invalid chars
+lut_hi[2] = 0x0  # ['\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17']
+lut_hi[3] = 0x0  # ['\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f']
+
+lut_hi[4] = 0x1  # can have spaces [' ', '!', '"', '#', '$', '%', '&', "'"]
+lut_lo[ord(" ") & 0xF] |= 0x1
+
+lut_hi[5] = 0x6  # for + and / ['(', ')', '*', '+', ',', '-', '.', '/']
+
+lut_lo[ord("+") & 0xF] |= 0x2
+lut_lo[ord("/") & 0xF] |= 0x4
+
+# 0x30 numbers
+lut_hi[0x6] = 0x8  # ['0', '1', '2', '3', '4', '5', '6', '7']
+lut_hi[0x7] = 0x8  # ['8', '9', ':', ';', '<', '=', '>', '?']
+for z in range(0, 10):
+    lut_lo[z] |= 0x8
+
+# 0x40, 0x60 letters
+lut_hi[0x8] = 0x10  # ['@', 'A', 'B', 'C', 'D', 'E', 'F', 'G']
+lut_hi[0x9] = 0x20  # ['H', 'I', 'J', 'K', 'L', 'M', 'N', 'O']
+lut_hi[10] = 0x20  # ['P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W']
+lut_hi[11] = 0x10  # ['X', 'Y', 'Z', '[', '\\', ']', '^', '_']
+
+lut_lo[ord("A") & 0xF] |= 0x10
+lut_lo[ord("B") & 0xF] |= 0x10
+lut_lo[ord("C") & 0xF] |= 0x10
+lut_lo[ord("D") & 0xF] |= 0x10
+lut_lo[ord("E") & 0xF] |= 0x10
+lut_lo[ord("F") & 0xF] |= 0x10
+lut_lo[ord("G") & 0xF] |= 0x10
+lut_lo[ord("X") & 0xF] |= 0x10
+lut_lo[ord("Y") & 0xF] |= 0x10
+lut_lo[ord("Z") & 0xF] |= 0x10
+
+lut_hi[12] = 0x40  # ['`', 'a', 'b', 'c', 'd', 'e', 'f', 'g']
+lut_hi[13] = 0x80  # ['h', 'i', 'j', 'k', 'l', 'm', 'n', 'o']
+lut_hi[14] = 0x80  # ['p', 'q', 'r', 's', 't', 'u', 'v', 'w']
+lut_hi[15] = 0x40  # ['x', 'y', 'z', '{', '|', '}', '~', '\x7f']
+
+lut_lo[ord("a") & 0xF] |= 0x40
+lut_lo[ord("b") & 0xF] |= 0x40
+lut_lo[ord("c") & 0xF] |= 0x40
+lut_lo[ord("d") & 0xF] |= 0x40
+lut_lo[ord("e") & 0xF] |= 0x40
+lut_lo[ord("f") & 0xF] |= 0x40
+lut_lo[ord("g") & 0xF] |= 0x40
+lut_lo[ord("x") & 0xF] |= 0x40
+lut_lo[ord("y") & 0xF] |= 0x40
+lut_lo[ord("z") & 0xF] |= 0x40
+
+for z in range(0, 16):
+    lut_lo[z] |= 0x80 | 0x20
+
+print("base64 regular lut_lo")
+print(",".join([hex(c) for c in lut_lo]))
+print("base64 regular lut_hi")
+print(",".join([hex(c) for c in lut_hi]))
+
+lut_lo[ord("-") & 0xF] |= 0x4
+lut_lo[ord("+") & 0xF] &= ~0x2
+lut_lo[ord("/") & 0xF] &= ~0x4
+lut_lo[ord("_") & 0xF] |= 0x2
+lut_hi[11] = 0x12  # can have _ as well ['X', 'Y', 'Z', '[', '\\', ']', '^', '_']
+lut_hi[5] = 0x4  # for - ['(', ')', '*', '+', ',', '-', '.', '/']
+print("base64 url lut_lo")
+print(",".join([hex(c) for c in lut_lo]))
+print("base64 url lut_hi")
+print(",".join([hex(c) for c in lut_hi]))
+
+lut_lo[ord("+") & 0xF] |= 0x2
+lut_lo[ord("/") & 0xF] |= 0x4
+lut_hi[5] = 0x6  # for +, - and / ['(', ')', '*', '+', ',', '-', '.', '/']
+print("base64 hybrid lut_lo")
+print(",".join([hex(c) for c in lut_lo]))
+print("base64 hybrid lut_hi")
+print(",".join([hex(c) for c in lut_hi]))

package/deps/simdutf/scripts/base64/sse.py

@@ -0,0 +1,252 @@
+import sys
+delta_asso = [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,0x00, 0x00, 0x00, 0x0F, 0x00, 0x0F]
+check_asso = [0x0D, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x07, 0x0B, 0x0B, 0x0B, 0x0F]
+
+delta_values =[(0x00), (0x00), (0x00), (0x13), (0x04), (0xBF), (0xBF), (0xB9), (0xB9), (0x00), (0x10), (0xC3), (0xBF), (0xBF), (0xB9), (0xB9)]
+check_values = [(0x80), (0x80), (0x80), (0x80), (0xCF), (0xBF), (0xD5), (0xA6), (0xB5), (0x86), (0xD1), (0x80), (0xB1), (0x80), (0x91), (0x80)]
+
+
+valid = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+
+def safechr(i):
+    if i < 32:
+        return '.'
+    if i > 127:
+        return '?'
+    return chr(i)
+
+def safehex(x):
+    return "0x{0:2x}".format(x)
+
+def to_signed(x):
+    if(x >= 128):
+        return x - 256
+    return x
+
+def to_unsigned(x):
+    if(x < 0):
+        return x + 256
+    return x
+
+def sat(x, y):
+    x = to_signed(x)
+    y = to_signed(y)
+    z = x + y
+    if(z > 127):
+        return 127
+    if(z < -128):
+        return to_unsigned(-128)
+    return to_unsigned(z)
+
+def lookup(table, index):
+    print("looking up ", hex(index))
+    if(index >= 128):
+        return 0
+    return table[index&0xf]
+
+
+
+def quietlookup(table, index):
+    if(index >= 128):
+        return 0
+    return table[index&0xf]
+
+def process(src):
+    shifted = (src >> 3)%256
+    delta_hash = (lookup(delta_asso,src) + shifted + 1) >> 1
+    check_hash = (lookup(check_asso,src) + shifted + 1) >> 1
+    out = sat(lookup(delta_values,delta_hash), src)
+    chk = sat(lookup(check_values,check_hash), src)
+    mask = chk & 0x80
+    return (out, mask)
+
+def processquiet(src):
+    shifted = (src >> 3)%256
+    delta_hash = (quietlookup(delta_asso,src) + shifted + 1) >> 1
+    check_hash = (quietlookup(check_asso,src) + shifted + 1) >> 1
+    out = sat(quietlookup(delta_values,delta_hash), src)
+    chk = sat(quietlookup(check_values,check_hash), src)
+    mask = chk & 0x80
+    return (out, mask)
+
+def is_ok(i):
+    out, mask = processquiet(i)
+    if mask == 0:
+        return 1
+    return 0
+
+def computestring():
+    s = ""
+    for i in range(256):
+        out, mask = processquiet(i)
+        if(mask == 0):
+            s +=  safechr(i)
+    return s
+print(computestring() + " " + str(len(computestring())))
+
+def print_layout():
+    t={}
+    for i in range(256):
+        src = i
+        shifted = (src >> 3)%256
+        check_hash = (quietlookup(check_asso,src) + shifted + 1) >> 1
+        if check_hash not in t:
+            t[check_hash] = []
+        t[check_hash].append(i)
+    for check_hash in range(16):
+        if check_hash in t:
+            off = quietlookup(check_values,check_hash)
+            print(hex(check_hash), hex(off), end="")
+            print("\t", " ".join(["   "+safechr(c) for c in t[check_hash]]))
+        else:
+            continue
+
+
+def is_valid():
+    t={}
+    for i in range(256):
+        src = i
+        shifted = (src >> 3)%256
+        check_hash = (quietlookup(check_asso,src) + shifted + 1) >> 1
+        if check_hash not in t:
+            t[check_hash] = []
+        t[check_hash].append(i)
+    for check_hash in t.keys():
+        if check_hash in t:
+            array = t[check_hash]
+            i = 0
+            while i < len(array) and valid.find(chr(array[i])) == -1:
+                i += 1
+            while i < len(array) and valid.find(chr(array[i])) != -1:
+                i += 1
+            while i < len(array) and array[i] >= 128:
+                i += 1
+            if i < len(array):
+                return False
+        else:
+            continue
+    return True
+
+print_layout()
+print(is_valid())
+
+valid = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
+print("----")
+def fun_adjust():
+    for zz in range(256):
+        check_asso[ord('-')&0xf] = zz
+        for yy in range(256):
+            check_asso[ord('_')&0xf] = yy
+            if(is_valid()):
+                print("----")
+                print_layout()
+                print(is_valid())
+                print("found")
+                return
+fun_adjust()
+            #sys.exit(0)
+
+def adjust(array, start, end, check_hash):
+    for j in range(256):
+        is_ok = True
+        for i in range(len(array)):
+            valid = (sat(j,array[i])&0x80 == 0) # sat(quietlookup(check_values,check_hash), src)
+            should_be_valid = (i>=start and i < end)
+            is_ok = is_ok and (valid == should_be_valid)
+        if(is_ok):
+            check_values[check_hash&0xf] = j
+            return
+    raise "unexpected"
+
+
+    chk = sat(quietlookup(check_values,check_hash), src)
+    mask = chk & 0x80
+
+def process_explicit():
+    t={}
+    for i in range(256):
+        src = i
+        shifted = (src >> 3)%256
+        check_hash = (quietlookup(check_asso,src) + shifted + 1) >> 1
+        if check_hash not in t:
+            t[check_hash] = []
+        t[check_hash].append(i)
+    for check_hash in t.keys():
+        if check_hash in t:
+            array = t[check_hash]
+            i = 0
+            while i < len(array) and valid.find(chr(array[i])) == -1:
+                i += 1
+            if i < len(array) and valid.find(chr(array[i])) != -1:
+                start = i
+                while i < len(array) and valid.find(chr(array[i])) != -1:
+                    i += 1
+                end = i
+                adjust(array, start, end, check_hash)
+        else:
+            continue
+    return True
+print("process")
+process_explicit()
+print("string")
+print(computestring()+ " "+str(len(computestring())))
+
+for c in valid:
+    print(c,processquiet(ord(c)))
+
+def examine():
+    t={}
+    for i in valid:
+        src = ord(i)
+        shifted = (src >> 3)%256
+        check_hash = (quietlookup(delta_asso,src) + shifted + 1) >> 1
+        if check_hash not in t:
+            t[check_hash] = []
+        t[check_hash].append(i)
+    for check_hash in t.keys():
+        print(check_hash, t[check_hash])
+    return True
+examine()
+
+delta_values[10] += 1 
+
+delta_values[13] += 33 
+
+for c in valid:
+    print(c,processquiet(ord(c)))
+
+
+
+def casthex(v):
+    if(v >= 0x80):
+        return "uint8_t("+"0x{:X}".format(v)+")"
+    return "0x{:X}".format(v)
+def printme(c):
+    print(",".join([casthex(i) for i in c]))
+print("delta_asso")
+printme(delta_asso)
+print("check_asso")
+printme(check_asso)
+print("delta_values")
+printme(delta_values)
+print("check_values")
+printme(check_values)
+
+def processverbose(src):
+    print("processing ", hex(src))
+    shifted = (src >> 3)%256
+    print("shifted ", hex(shifted))
+    delta_hash = (lookup(delta_asso,src) + shifted + 1) >> 1
+    print("delta_hash ", hex(delta_hash))
+    check_hash = (lookup(check_asso,src) + shifted + 1) >> 1
+    print("check_hash ", hex(check_hash))
+    out = sat(lookup(delta_values,delta_hash), src)
+    print("out ", hex(out))
+    chk = sat(lookup(check_values,check_hash), src)
+    print("chk ", hex(chk))
+
+    mask = chk & 0x80
+    return (out, mask)
+processverbose(ord('-'))
+
+print(computestring()+ " "+str(len(computestring())))

package/deps/simdutf/scripts/base64/sseregular.py

@@ -0,0 +1,160 @@
+import sys
+delta_asso = [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,0x00, 0x00, 0x00, 0x0F, 0x00, 0x0F]
+check_asso = [0x0D, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x07, 0x0B, 0x0B, 0x0B, 0x0F]
+
+delta_values =[(0x00), (0x00), (0x00), (0x13), (0x04), (0xBF), (0xBF), (0xB9), (0xB9), (0x00), (0x10), (0xC3), (0xBF), (0xBF), (0xB9), (0xB9)]
+check_values = [(0x80), (0x80), (0x80), (0x80), (0xCF), (0xBF), (0xD5), (0xA6), (0xB5), (0x86), (0xD1), (0x80), (0xB1), (0x80), (0x91), (0x80)]
+
+
+valid = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+
+def safechr(i):
+    if i < 32:
+        return '.'
+    if i > 127:
+        return '?'
+    return chr(i)
+
+def safehex(x):
+    return "0x{0:2x}".format(x)
+
+def to_signed(x):
+    if(x >= 128):
+        return x - 256
+    return x
+
+def to_unsigned(x):
+    if(x < 0):
+        return x + 256
+    return x
+
+def sat(x, y):
+    x = to_signed(x)
+    y = to_signed(y)
+    z = x + y
+    if(z > 127):
+        return 127
+    if(z < -128):
+        return to_unsigned(-128)
+    return to_unsigned(z)
+
+def lookup(table, index):
+    print("looking up ", hex(index))
+    if(index >= 128):
+        return 0
+    return table[index&0xf]
+
+
+
+def quietlookup(table, index):
+    if(index >= 128):
+        return 0
+    return table[index&0xf]
+
+def process(src):
+    shifted = (src >> 3)%256
+    delta_hash = (lookup(delta_asso,src) + shifted + 1) >> 1
+    check_hash = (lookup(check_asso,src) + shifted + 1) >> 1
+    out = sat(lookup(delta_values,delta_hash), src)
+    chk = sat(lookup(check_values,check_hash), src)
+    mask = chk & 0x80
+    return (out, mask)
+
+def processquiet(src):
+    shifted = (src >> 3)%256
+    delta_hash = (quietlookup(delta_asso,src) + shifted + 1) >> 1
+    check_hash = (quietlookup(check_asso,src) + shifted + 1) >> 1
+    out = sat(quietlookup(delta_values,delta_hash), src)
+    chk = sat(quietlookup(check_values,check_hash), src)
+    mask = chk & 0x80
+    return (out, mask)
+
+def is_ok(i):
+    out, mask = processquiet(i)
+    if mask == 0:
+        return 1
+    return 0
+
+def computestring():
+    s = ""
+    for i in range(256):
+        out, mask = processquiet(i)
+        if(mask == 0):
+            s +=  safechr(i)
+    return s
+print(computestring() + " " + str(len(computestring())))
+
+def print_layout():
+    t={}
+    for i in range(256):
+        src = i
+        shifted = (src >> 3)%256
+        check_hash = (quietlookup(check_asso,src) + shifted + 1) >> 1
+        if check_hash not in t:
+            t[check_hash] = []
+        t[check_hash].append(i)
+    for check_hash in range(16):
+        if check_hash in t:
+            off = quietlookup(check_values,check_hash)
+            print(hex(check_hash), hex(off), end="")
+            print("\t", " ".join(["   "+safechr(c) for c in t[check_hash]]))
+        else:
+            continue
+
+
+def is_valid():
+    t={}
+    for i in range(256):
+        src = i
+        shifted = (src >> 3)%256
+        check_hash = (quietlookup(check_asso,src) + shifted + 1) >> 1
+        if check_hash not in t:
+            t[check_hash] = []
+        t[check_hash].append(i)
+    for check_hash in t.keys():
+        if check_hash in t:
+            array = t[check_hash]
+            i = 0
+            while i < len(array) and valid.find(chr(array[i])) == -1:
+                i += 1
+            while i < len(array) and valid.find(chr(array[i])) != -1:
+                i += 1
+            while i < len(array) and array[i] >= 128:
+                i += 1
+            if i < len(array):
+                return False
+        else:
+            continue
+    return True
+
+print_layout()
+print(is_valid())
+
+
+def is_base64(src):
+    is_base64 = None
+    for i in range(8):
+        shifted = (src >> 3)%256
+        shifted += i << 5
+        #print("shifted ", hex(shifted))
+        delta_hash = (quietlookup(delta_asso,src) + shifted + 1) >> 1
+        #print("delta_hash ", hex(delta_hash))
+        check_hash = (quietlookup(check_asso,src) + shifted + 1) >> 1
+        #print("check_hash ", hex(check_hash))
+        out = sat(quietlookup(delta_values,delta_hash), src)
+        #print("out ", hex(out))
+        chk = sat(quietlookup(check_values,check_hash), src)
+        this_is_base64 = chk & 0x80 == 0
+        if is_base64 is None:
+            is_base64 = this_is_base64
+        else:
+            if is_base64 != this_is_base64:
+                print("unexpected")
+                return None
+    return is_base64
+
+for i in range(256):
+    if is_base64(i):
+        print(chr(i), end=",")
+    elif is_base64(i) is None:
+        print("None", hex(i), end=",")