alphanum = b"_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
anl = len(alphanum)+1
c = 0xFFFFFFFFFFFFFFFF
e = anl-10
d = 0
while e<c:
    d += 1
    e *= anl
print(anl, "chars")
print(d, "max length for 64 bits")
alphanumc = [ None for i in range(256) ]
for v, k in enumerate(alphanum):
    alphanumc[k] = v+1

def encode(s):
    r = 0
    if not s:
        return r
    if s[0] in b"0123456789":
        raise RuntimeError("name cannot start with a digit")
    for c in s:
        r *= anl
        r += alphanumc[c]
    return r

def decode(s):
    r = []
    while s:
        s, n = divmod(s, anl)
        r.append(alphanum[n-1:n])
    return b"".join(r[::-1])

s = b"hookovercrookthroughbooze"

print(decode(encode(s)))


from collections.abc import MutableMapping
class Node(MutableMapping):
    def __init__(self):
        self.children = [None, None]
    def __getitem__(self, key):
        data = self.children[key&1]
        if isinstance(data, Node):
            return data[key>>1]
        else:
            return data
    def __setitem__(self, key, value):
        data = self.children[key&1]
        if isinstance(data, Node):
            data[key>>1] = value
        elif key < 2:
            self.children[key&1] = value
        else:
            self.children[key&1] = Node()
            self.children[key&1][0] = data
            self.children[key&1][key>>1] = value
    def __delitem__(self, key):
        data = self.children[key&1]
        if isinstance(data, Node):
            data[key>>1] = None
        elif key < 2:
            self.children[key&1] = None
    def __iter__(self):
        def it():
            for k, v in enumerate(self.children):
                if isinstance(v, Node):
                    for sk in iter(v):
                        yield (sk<<1)|k
                elif v is not None:
                    yield k
        return it()
    def __len__(self):
        return len([k for k in iter(self)])

class MyMapping(Node):
    def __init__(self, d=None):
        Node.__init__(self)
        if d is not None:
            for k in d:
                self[k] = d[k]
    def __getitem__(self, key):
        return Node.__getitem__(self, encode(key))
    def __setitem__(self, key, value):
        Node.__setitem__(self, encode(key), value)
    def __delitem__(self, key):
        Node.__delitem__(self, encode(key))
    def __iter__(self):
        def it():
            for k in Node.__iter__(self):
                yield decode(k)
        return it()

test = MyMapping({b"mykey": b"myvalue"})
test[b"myanotherkey"] = b"myanothervalue"
print(test[b"mykey"])
for k in test:
    print(k, test[k])