sw-serverless 10.2.3__py3-none-any.whl

sw_serverless/__init__.py

@@ -0,0 +1,28 @@
+"""Write SW-Serverless adapters in Python.
+
+    import sw_serverless as sw
+
+    class Greeter:
+        def __init__(self):
+            sw.expect("Greeting", "Hello", description="What to say")
+
+        @sw.command(description="Greets someone")
+        def greet(self, name: str) -> str:
+            return f"{sw.value_of('Greeting')}, {name}"
+
+    if __name__ == "__main__":
+        sw.run(Greeter)
+
+``python adapter.py --describe`` prints what it is; the host runs it otherwise. An adapter with a
+``start`` hook is resident: it runs until stopped, with ``stop``, ``status`` and ``reset`` hooks.
+"""
+
+from ._adapter import command, declared_settings, expect, implements, startup_values, value_of
+from ._runner import SDK_VERSION, AdapterError, Context, context, describe, run
+
+__version__ = SDK_VERSION
+
+__all__ = [
+    "AdapterError", "Context", "SDK_VERSION", "command", "context", "declared_settings", "describe",
+    "expect", "implements", "run", "startup_values", "value_of",
+]

sw_serverless/_adapter.py

@@ -0,0 +1,180 @@
+"""Declaring an adapter: its settings, its commands, its kinds and contracts.
+
+Settings are declared once, in code, with :func:`expect` — the Python form of the .NET SDK's
+``Runner.Expect`` — and reach the manifest through ``--describe`` and the host through ``Hello``.
+"""
+
+import contextvars
+import inspect
+import typing
+
+from . import _types
+
+SETTING_TYPES = ("text", "multiline", "number", "boolean", "select", "json")
+
+
+class Setting:
+    def __init__(self, name, default, required, secret, description, type):
+        self.name = name
+        self.default = default
+        self.required = required
+        self.secret = secret
+        self.description = description
+        self.type = type
+
+    def describe(self):
+        return {"name": self.name, "description": self.description, "type": self.type,
+                "required": self.required, "secret": self.secret, "default": self.default}
+
+
+_settings = {}
+
+
+def expect(name, default=None, *, required=None, secret=False, description=None, type="text"):
+    """Declares a setting the adapter reads.
+
+    Required unless it has a default or ``required=False`` says otherwise. A secret is masked
+    wherever a host application shows it. Declaring the same name again replaces it.
+    """
+    if not name or not isinstance(name, str):
+        raise ValueError("a setting needs a name")
+    if type not in SETTING_TYPES:
+        raise ValueError(f"setting type must be one of {', '.join(SETTING_TYPES)}")
+    if required is None:
+        required = default is None
+    _settings[name] = Setting(name, None if default is None else str(default), bool(required), bool(secret),
+                              description, type)
+    return name
+
+
+def declared_settings():
+    return list(_settings.values())
+
+
+# The values a call sees: this invocation's properties over the process's startup values.
+_startup_values = {}
+_call_values = contextvars.ContextVar("sw_call_values", default=None)
+
+
+def value_of(name, default=None):
+    """A setting's value for the current call: the call's own properties, then the values the
+    adapter was started with, then the declared default, then ``default``."""
+    call = _call_values.get()
+    if call and name in call:
+        return call[name]
+    if name in _startup_values:
+        return _startup_values[name]
+    declared = _settings.get(name)
+    if declared is not None and declared.default is not None:
+        return declared.default
+    return default
+
+
+def startup_values():
+    return dict(_startup_values)
+
+
+def command(name=None, *, description=None):
+    """Marks a method as a command the host can call, under ``name`` or the method's own name."""
+
+    def mark(fn):
+        fn.__sw_command__ = {"name": name or fn.__name__, "description": description}
+        return fn
+
+    if callable(name):  # used bare: @command
+        fn, name = name, None
+        return mark(fn)
+    return mark
+
+
+class Command:
+    def __init__(self, name, method, description):
+        self.name = name
+        self.method = method
+        self.description = description
+        signature = inspect.signature(method)
+        parameters = [p for p in signature.parameters.values()
+                      if p.name != "self" and p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)]
+        if len(parameters) > 1:
+            raise TypeError(f"command {name} takes {len(parameters)} arguments; a command takes at most one")
+        try:
+            hints = typing.get_type_hints(method)
+        except Exception:
+            hints = {}
+        self.takes_argument = bool(parameters)
+        self.argument_type = hints.get(parameters[0].name, _types._EMPTY) if parameters else None
+        returns = hints.get("return", signature.return_annotation)
+        self.returns_value = returns not in (None, type(None))
+        self.result_type = returns
+
+    def info(self):
+        input_schema = _types.schema(self.argument_type) if self.takes_argument else None
+        output_schema = _types.schema(self.result_type) if self.returns_value else None
+        return {"name": self.name, "description": self.description, "takes_argument": self.takes_argument,
+                "returns_value": self.returns_value, "input_schema": input_schema, "output_schema": output_schema,
+                "parameter_type": _type_name(self.argument_type) if self.takes_argument else ""}
+
+
+def _type_name(tp):
+    if tp in (_types._EMPTY, None):
+        return "object"
+    return getattr(tp, "__name__", str(tp))
+
+
+def implements(contract, version, *kinds):
+    """Declares, on an adapter class, a contract it implements and the kinds of it it is.
+
+        @sw.implements("orders", 1, "processor")
+        class Orders: ...
+
+    A host application's contract package does this for its own base classes."""
+
+    if not contract or not isinstance(version, int):
+        raise ValueError("a contract needs a name and an integer version")
+
+    def mark(cls):
+        contracts = dict(vars(cls).get("__sw_contracts__", {}))
+        contracts[contract] = version
+        cls.__sw_contracts__ = contracts
+        cls.__sw_kinds__ = list(dict.fromkeys([*vars(cls).get("__sw_kinds__", []), *kinds]))
+        return cls
+
+    return mark
+
+
+def commands_of(adapter):
+    """Every command on the adapter's class, by wire name. Kinds' base classes add their own."""
+    found = {}
+    cls = adapter if isinstance(adapter, type) else type(adapter)
+    for klass in reversed(cls.__mro__):
+        for attr, value in vars(klass).items():
+            marker = getattr(value, "__sw_command__", None)
+            if marker:
+                found[marker["name"]] = attr
+    result = {}
+    for wire_name, attr in found.items():
+        method = getattr(adapter, attr)
+        marker = getattr(getattr(cls, attr), "__sw_command__", None) or {}
+        result[wire_name] = Command(wire_name, method, marker.get("description"))
+    return result
+
+
+def kinds_of(cls):
+    kinds = []
+    for klass in cls.__mro__:
+        for kind in getattr(klass, "__sw_kinds__", ()) or ():
+            if kind not in kinds:
+                kinds.append(kind)
+    return kinds
+
+
+def contracts_of(cls):
+    contracts = {}
+    for klass in reversed(cls.__mro__):
+        contracts.update(getattr(klass, "__sw_contracts__", {}) or {})
+    return contracts
+
+
+def is_resident(cls):
+    """Resident when it has a start hook: it runs until stopped rather than for one session."""
+    return callable(getattr(cls, "start", None))

sw_serverless/_hpack.py

@@ -0,0 +1,186 @@
+"""HPACK (RFC 7541): enough to talk to the host.
+
+The adapter sends one set of request headers, encoded as literals without indexing, which every
+decoder accepts. What the host sends back is decoded in full: static and dynamic tables, size
+updates and Huffman-coded strings, since a server is free to use all of them.
+"""
+
+from ._huffman import CODES
+
+STATIC_TABLE = (
+    (":authority", ""), (":method", "GET"), (":method", "POST"), (":path", "/"),
+    (":path", "/index.html"), (":scheme", "http"), (":scheme", "https"), (":status", "200"),
+    (":status", "204"), (":status", "206"), (":status", "304"), (":status", "400"),
+    (":status", "404"), (":status", "500"), ("accept-charset", ""), ("accept-encoding", "gzip, deflate"),
+    ("accept-language", ""), ("accept-ranges", ""), ("accept", ""), ("access-control-allow-origin", ""),
+    ("age", ""), ("allow", ""), ("authorization", ""), ("cache-control", ""),
+    ("content-disposition", ""), ("content-encoding", ""), ("content-language", ""), ("content-length", ""),
+    ("content-location", ""), ("content-range", ""), ("content-type", ""), ("cookie", ""),
+    ("date", ""), ("etag", ""), ("expect", ""), ("expires", ""),
+    ("from", ""), ("host", ""), ("if-match", ""), ("if-modified-since", ""),
+    ("if-none-match", ""), ("if-range", ""), ("if-unmodified-since", ""), ("last-modified", ""),
+    ("link", ""), ("location", ""), ("max-forwards", ""), ("proxy-authenticate", ""),
+    ("proxy-authorization", ""), ("range", ""), ("referer", ""), ("refresh", ""),
+    ("retry-after", ""), ("server", ""), ("set-cookie", ""), ("strict-transport-security", ""),
+    ("transfer-encoding", ""), ("user-agent", ""), ("vary", ""), ("via", ""),
+    ("www-authenticate", ""),
+)
+
+
+class HpackError(Exception):
+    pass
+
+
+def _huffman_tree():
+    # A binary trie over the codes: each node is [child0, child1, symbol].
+    root = [None, None, None]
+    for symbol, (code, length) in enumerate(CODES):
+        node = root
+        for bit in range(length - 1, -1, -1):
+            b = (code >> bit) & 1
+            if node[b] is None:
+                node[b] = [None, None, None]
+            node = node[b]
+        node[2] = symbol
+    return root
+
+
+_TREE = _huffman_tree()
+
+
+def huffman_decode(data):
+    out = bytearray()
+    node = _TREE
+    depth = 0
+    for byte in data:
+        for bit in range(7, -1, -1):
+            node = node[(byte >> bit) & 1]
+            depth += 1
+            if node is None:
+                raise HpackError("invalid Huffman code")
+            if node[2] is not None:
+                if node[2] == 256:
+                    raise HpackError("EOS symbol in a Huffman string")
+                out.append(node[2])
+                node = _TREE
+                depth = 0
+    # Padding is the most significant bits of EOS (all ones), and shorter than a byte.
+    if depth > 7:
+        raise HpackError("Huffman padding longer than 7 bits")
+    return bytes(out)
+
+
+def _decode_int(data, pos, prefix_bits):
+    mask = (1 << prefix_bits) - 1
+    value = data[pos] & mask
+    pos += 1
+    if value < mask:
+        return value, pos
+    shift = 0
+    while True:
+        if pos >= len(data):
+            raise HpackError("truncated integer")
+        byte = data[pos]
+        pos += 1
+        value += (byte & 0x7F) << shift
+        shift += 7
+        if not byte & 0x80:
+            return value, pos
+
+
+def _encode_int(value, prefix_bits, first_byte_flags=0):
+    mask = (1 << prefix_bits) - 1
+    if value < mask:
+        return bytes([first_byte_flags | value])
+    out = bytearray([first_byte_flags | mask])
+    value -= mask
+    while value >= 0x80:
+        out.append((value & 0x7F) | 0x80)
+        value >>= 7
+    out.append(value)
+    return bytes(out)
+
+
+def _decode_string(data, pos):
+    if pos >= len(data):
+        raise HpackError("truncated string")
+    huffman = data[pos] & 0x80
+    length, pos = _decode_int(data, pos, 7)
+    raw = data[pos:pos + length]
+    if len(raw) != length:
+        raise HpackError("truncated string")
+    pos += length
+    return (huffman_decode(raw) if huffman else bytes(raw)).decode("latin-1"), pos
+
+
+def _encode_string(text):
+    raw = text.encode("latin-1")
+    return _encode_int(len(raw), 7) + raw
+
+
+def encode(headers):
+    """Headers as literals without indexing: never touch either side's dynamic table."""
+    out = bytearray()
+    for name, value in headers:
+        out += b"\x00" + _encode_string(name) + _encode_string(value)
+    return bytes(out)
+
+
+class Decoder:
+    def __init__(self, max_size=4096):
+        self.max_size = max_size
+        self.size = 0
+        self.dynamic = []  # newest first
+
+    @staticmethod
+    def _entry_size(name, value):
+        return len(name.encode("latin-1")) + len(value.encode("latin-1")) + 32
+
+    def _evict(self):
+        while self.size > self.max_size and self.dynamic:
+            name, value = self.dynamic.pop()
+            self.size -= self._entry_size(name, value)
+
+    def _add(self, name, value):
+        self.dynamic.insert(0, (name, value))
+        self.size += self._entry_size(name, value)
+        self._evict()
+
+    def _lookup(self, index):
+        if index <= 0:
+            raise HpackError("index 0")
+        if index <= len(STATIC_TABLE):
+            return STATIC_TABLE[index - 1]
+        index -= len(STATIC_TABLE) + 1
+        if index >= len(self.dynamic):
+            raise HpackError("index past the dynamic table")
+        return self.dynamic[index]
+
+    def decode(self, data):
+        headers = []
+        pos = 0
+        while pos < len(data):
+            byte = data[pos]
+            if byte & 0x80:  # indexed
+                index, pos = _decode_int(data, pos, 7)
+                headers.append(self._lookup(index))
+            elif byte & 0x40:  # literal, incremental indexing
+                index, pos = _decode_int(data, pos, 6)
+                name = self._lookup(index)[0] if index else None
+                if name is None:
+                    name, pos = _decode_string(data, pos)
+                value, pos = _decode_string(data, pos)
+                self._add(name, value)
+                headers.append((name, value))
+            elif byte & 0x20:  # dynamic table size update
+                size, pos = _decode_int(data, pos, 5)
+                self.max_size = size
+                self._evict()
+            else:  # literal without indexing (0000) or never indexed (0001)
+                index, pos = _decode_int(data, pos, 4)
+                name = self._lookup(index)[0] if index else None
+                if name is None:
+                    name, pos = _decode_string(data, pos)
+                value, pos = _decode_string(data, pos)
+                headers.append((name, value))
+        return headers

sw_serverless/_http2.py

@@ -0,0 +1,253 @@
+"""One gRPC bidirectional stream over HTTP/2 cleartext (h2c, prior knowledge), on asyncio.
+
+The host serves gRPC on a Unix domain socket and the adapter opens exactly one call on it, Attach,
+for its whole life. That is all this implements: one client stream, the frames it needs, and flow
+control in both directions — the part that matters, since a result can be 64 MB and the default
+window is 64 KB.
+"""
+
+import asyncio
+import struct
+
+from . import _hpack
+
+PREFACE = b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
+
+DATA, HEADERS, PRIORITY, RST_STREAM, SETTINGS, PUSH_PROMISE, PING, GOAWAY, WINDOW_UPDATE, CONTINUATION = range(10)
+END_STREAM, ACK, END_HEADERS, PADDED, PRIORITY_FLAG = 0x1, 0x1, 0x4, 0x8, 0x20
+
+SETTINGS_HEADER_TABLE_SIZE, SETTINGS_INITIAL_WINDOW_SIZE, SETTINGS_MAX_FRAME_SIZE = 0x1, 0x4, 0x5
+
+STREAM_ID = 1
+DEFAULT_WINDOW = 65535
+# What the adapter lets the host send before it acknowledges: large, so a big payload is not
+# trickled through 64 KB at a time.
+RECEIVE_WINDOW = 16 * 1024 * 1024
+MAX_MESSAGE = 64 * 1024 * 1024
+
+
+class GrpcError(Exception):
+    def __init__(self, status, message):
+        super().__init__(f"gRPC status {status}: {message}")
+        self.status = status
+
+
+class GrpcStream:
+    """Attach: write messages, read messages, and know when the host has ended the call."""
+
+    def __init__(self, reader, writer, path):
+        self._reader = reader
+        self._writer = writer
+        self._path = path
+        self._decoder = _hpack.Decoder()
+        # Messages go out whole and in order, under the message lock, which may wait for window.
+        # Every socket write takes only the write lock, briefly, so the read loop can still
+        # acknowledge frames — and so receive the WINDOW_UPDATE that wait is for.
+        self._message_lock = asyncio.Lock()
+        self._write_lock = asyncio.Lock()
+        self._window_changed = asyncio.Condition()
+        self._conn_send_window = DEFAULT_WINDOW
+        self._stream_send_window = DEFAULT_WINDOW
+        self._peer_initial_window = DEFAULT_WINDOW
+        self._peer_max_frame = 16384
+        self._inbound = asyncio.Queue()
+        self._buffer = bytearray()
+        self._header_block = bytearray()
+        self._header_stream = 0
+        self._header_end_stream = False
+        self._closed = False
+        self._read_task = None
+
+    @classmethod
+    async def open(cls, socket_path, path):
+        reader, writer = await asyncio.open_unix_connection(socket_path, limit=2 ** 20)
+        stream = cls(reader, writer, path)
+        await stream._start()
+        return stream
+
+    # ------------------------------------------------------------------ framing
+
+    def _frame(self, frame_type, flags, stream_id, payload=b""):
+        return struct.pack(">I", len(payload))[1:] + bytes([frame_type, flags]) + struct.pack(">I", stream_id) + payload
+
+    async def _write(self, data):
+        async with self._write_lock:
+            self._writer.write(data)
+            await self._writer.drain()
+
+    async def _start(self):
+        settings = struct.pack(">HI", SETTINGS_INITIAL_WINDOW_SIZE, RECEIVE_WINDOW)
+        # Raise the connection-level window too; it starts at 64 KB whatever SETTINGS says.
+        grow = struct.pack(">I", RECEIVE_WINDOW - DEFAULT_WINDOW)
+        headers = _hpack.encode([
+            (":method", "POST"), (":scheme", "http"), (":path", self._path), (":authority", "localhost"),
+            ("content-type", "application/grpc"), ("te", "trailers"),
+            ("user-agent", "sw-serverless-python"),
+        ])
+        await self._write(
+            PREFACE
+            + self._frame(SETTINGS, 0, 0, settings)
+            + self._frame(WINDOW_UPDATE, 0, 0, grow)
+            + self._frame(HEADERS, END_HEADERS, STREAM_ID, headers))
+        self._read_task = asyncio.get_running_loop().create_task(self._read_loop())
+
+    # ------------------------------------------------------------------ sending
+
+    async def send(self, message):
+        if len(message) > MAX_MESSAGE:
+            raise ValueError(f"a message of {len(message)} bytes is more than the {MAX_MESSAGE} the host accepts")
+        data = b"\x00" + struct.pack(">I", len(message)) + message
+        async with self._message_lock:
+            pos = 0
+            while pos < len(data):
+                async with self._window_changed:
+                    await self._window_changed.wait_for(
+                        lambda: self._closed or (self._conn_send_window > 0 and self._stream_send_window > 0))
+                    if self._closed:
+                        raise ConnectionError("the host closed the stream")
+                    size = min(len(data) - pos, self._conn_send_window, self._stream_send_window, self._peer_max_frame)
+                    self._conn_send_window -= size
+                    self._stream_send_window -= size
+                await self._write(self._frame(DATA, 0, STREAM_ID, data[pos:pos + size]))
+                pos += size
+
+    async def close_send(self):
+        async with self._message_lock:
+            if not self._closed:
+                try:
+                    await self._write(self._frame(DATA, END_STREAM, STREAM_ID))
+                except (ConnectionError, OSError):
+                    pass
+
+    # ------------------------------------------------------------------ receiving
+
+    async def receive(self):
+        """The next message, or None once the host has ended the call."""
+        item = await self._inbound.get()
+        if isinstance(item, Exception):
+            raise item
+        return item
+
+    async def _read_loop(self):
+        try:
+            while True:
+                head = await self._reader.readexactly(9)
+                length = int.from_bytes(head[:3], "big")
+                frame_type, flags = head[3], head[4]
+                stream_id = int.from_bytes(head[5:9], "big") & 0x7FFFFFFF
+                payload = await self._reader.readexactly(length) if length else b""
+                if await self._on_frame(frame_type, flags, stream_id, payload):
+                    break
+            await self._inbound.put(None)
+        except (asyncio.IncompleteReadError, ConnectionError, OSError):
+            await self._inbound.put(None)
+        except Exception as ex:  # a protocol error: end the call rather than hang
+            await self._inbound.put(ex)
+        finally:
+            await self._mark_closed()
+
+    async def _mark_closed(self):
+        self._closed = True
+        async with self._window_changed:
+            self._window_changed.notify_all()
+
+    async def _on_frame(self, frame_type, flags, stream_id, payload):
+        """True when the call is over."""
+        if frame_type == SETTINGS:
+            if not flags & ACK:
+                await self._apply_settings(payload)
+                await self._write(self._frame(SETTINGS, ACK, 0))
+        elif frame_type == PING:
+            if not flags & ACK:
+                await self._write(self._frame(PING, ACK, 0, payload))
+        elif frame_type == WINDOW_UPDATE:
+            increment = int.from_bytes(payload[:4], "big") & 0x7FFFFFFF
+            async with self._window_changed:
+                if stream_id == 0:
+                    self._conn_send_window += increment
+                elif stream_id == STREAM_ID:
+                    self._stream_send_window += increment
+                self._window_changed.notify_all()
+        elif frame_type in (HEADERS, CONTINUATION):
+            if frame_type == HEADERS:
+                payload = self._strip(flags, payload, headers=True)
+                self._header_block = bytearray(payload)
+                self._header_stream = stream_id
+                self._header_end_stream = bool(flags & END_STREAM)
+            else:
+                self._header_block += payload
+            if flags & END_HEADERS:
+                headers = self._decoder.decode(bytes(self._header_block))
+                if self._header_stream == STREAM_ID:
+                    self._check_headers(headers)
+                    if self._header_end_stream:
+                        return True
+        elif frame_type == DATA:
+            data = self._strip(flags, payload)
+            if length := len(payload):
+                # Hand the window straight back: messages are consumed as they are parsed.
+                increment = struct.pack(">I", length)
+                await self._write(self._frame(WINDOW_UPDATE, 0, 0, increment)
+                                  + self._frame(WINDOW_UPDATE, 0, STREAM_ID, increment))
+            if stream_id == STREAM_ID:
+                self._buffer += data
+                await self._drain_messages()
+                if flags & END_STREAM:
+                    return True
+        elif frame_type == RST_STREAM and stream_id == STREAM_ID:
+            code = int.from_bytes(payload[:4], "big")
+            raise GrpcError(code, "the host reset the stream")
+        elif frame_type == GOAWAY:
+            return True
+        return False
+
+    async def _apply_settings(self, payload):
+        for i in range(0, len(payload) - 5, 6):
+            ident, value = struct.unpack(">HI", payload[i:i + 6])
+            if ident == SETTINGS_INITIAL_WINDOW_SIZE:
+                async with self._window_changed:
+                    self._stream_send_window += value - self._peer_initial_window
+                    self._peer_initial_window = value
+                    self._window_changed.notify_all()
+            elif ident == SETTINGS_MAX_FRAME_SIZE:
+                self._peer_max_frame = value
+
+    @staticmethod
+    def _strip(flags, payload, headers=False):
+        pad = 0
+        if flags & PADDED:
+            pad = payload[0]
+            payload = payload[1:]
+        if headers and flags & PRIORITY_FLAG:
+            payload = payload[5:]
+        return payload[:len(payload) - pad] if pad else payload
+
+    def _check_headers(self, headers):
+        values = dict(headers)
+        status = values.get(":status")
+        if status is not None and status != "200":
+            raise GrpcError(-1, f"HTTP status {status}")
+        grpc_status = values.get("grpc-status")
+        if grpc_status is not None and grpc_status != "0":
+            raise GrpcError(int(grpc_status), values.get("grpc-message", ""))
+
+    async def _drain_messages(self):
+        while len(self._buffer) >= 5:
+            if self._buffer[0] != 0:
+                raise GrpcError(-1, "compressed messages are not supported")
+            length = int.from_bytes(self._buffer[1:5], "big")
+            if len(self._buffer) < 5 + length:
+                return
+            message = bytes(self._buffer[5:5 + length])
+            del self._buffer[:5 + length]
+            await self._inbound.put(message)
+
+    async def aclose(self):
+        await self.close_send()
+        try:
+            self._writer.close()
+            await self._writer.wait_closed()
+        except (ConnectionError, OSError):
+            pass
+        if self._read_task:
+            self._read_task.cancel()

sw_serverless/_huffman.py

@@ -0,0 +1,37 @@
+"""The HPACK Huffman code, RFC 7541 Appendix B: (code, bit length) for each symbol 0-256."""
+
+CODES = (
+    (0x1ff8, 13), (0x7fffd8, 23), (0xfffffe2, 28), (0xfffffe3, 28), (0xfffffe4, 28), (0xfffffe5, 28), (0xfffffe6, 28), (0xfffffe7, 28),
+    (0xfffffe8, 28), (0xffffea, 24), (0x3ffffffc, 30), (0xfffffe9, 28), (0xfffffea, 28), (0x3ffffffd, 30), (0xfffffeb, 28), (0xfffffec, 28),
+    (0xfffffed, 28), (0xfffffee, 28), (0xfffffef, 28), (0xffffff0, 28), (0xffffff1, 28), (0xffffff2, 28), (0x3ffffffe, 30), (0xffffff3, 28),
+    (0xffffff4, 28), (0xffffff5, 28), (0xffffff6, 28), (0xffffff7, 28), (0xffffff8, 28), (0xffffff9, 28), (0xffffffa, 28), (0xffffffb, 28),
+    (0x14, 6), (0x3f8, 10), (0x3f9, 10), (0xffa, 12), (0x1ff9, 13), (0x15, 6), (0xf8, 8), (0x7fa, 11),
+    (0x3fa, 10), (0x3fb, 10), (0xf9, 8), (0x7fb, 11), (0xfa, 8), (0x16, 6), (0x17, 6), (0x18, 6),
+    (0x0, 5), (0x1, 5), (0x2, 5), (0x19, 6), (0x1a, 6), (0x1b, 6), (0x1c, 6), (0x1d, 6),
+    (0x1e, 6), (0x1f, 6), (0x5c, 7), (0xfb, 8), (0x7ffc, 15), (0x20, 6), (0xffb, 12), (0x3fc, 10),
+    (0x1ffa, 13), (0x21, 6), (0x5d, 7), (0x5e, 7), (0x5f, 7), (0x60, 7), (0x61, 7), (0x62, 7),
+    (0x63, 7), (0x64, 7), (0x65, 7), (0x66, 7), (0x67, 7), (0x68, 7), (0x69, 7), (0x6a, 7),
+    (0x6b, 7), (0x6c, 7), (0x6d, 7), (0x6e, 7), (0x6f, 7), (0x70, 7), (0x71, 7), (0x72, 7),
+    (0xfc, 8), (0x73, 7), (0xfd, 8), (0x1ffb, 13), (0x7fff0, 19), (0x1ffc, 13), (0x3ffc, 14), (0x22, 6),
+    (0x7ffd, 15), (0x3, 5), (0x23, 6), (0x4, 5), (0x24, 6), (0x5, 5), (0x25, 6), (0x26, 6),
+    (0x27, 6), (0x6, 5), (0x74, 7), (0x75, 7), (0x28, 6), (0x29, 6), (0x2a, 6), (0x7, 5),
+    (0x2b, 6), (0x76, 7), (0x2c, 6), (0x8, 5), (0x9, 5), (0x2d, 6), (0x77, 7), (0x78, 7),
+    (0x79, 7), (0x7a, 7), (0x7b, 7), (0x7ffe, 15), (0x7fc, 11), (0x3ffd, 14), (0x1ffd, 13), (0xffffffc, 28),
+    (0xfffe6, 20), (0x3fffd2, 22), (0xfffe7, 20), (0xfffe8, 20), (0x3fffd3, 22), (0x3fffd4, 22), (0x3fffd5, 22), (0x7fffd9, 23),
+    (0x3fffd6, 22), (0x7fffda, 23), (0x7fffdb, 23), (0x7fffdc, 23), (0x7fffdd, 23), (0x7fffde, 23), (0xffffeb, 24), (0x7fffdf, 23),
+    (0xffffec, 24), (0xffffed, 24), (0x3fffd7, 22), (0x7fffe0, 23), (0xffffee, 24), (0x7fffe1, 23), (0x7fffe2, 23), (0x7fffe3, 23),
+    (0x7fffe4, 23), (0x1fffdc, 21), (0x3fffd8, 22), (0x7fffe5, 23), (0x3fffd9, 22), (0x7fffe6, 23), (0x7fffe7, 23), (0xffffef, 24),
+    (0x3fffda, 22), (0x1fffdd, 21), (0xfffe9, 20), (0x3fffdb, 22), (0x3fffdc, 22), (0x7fffe8, 23), (0x7fffe9, 23), (0x1fffde, 21),
+    (0x7fffea, 23), (0x3fffdd, 22), (0x3fffde, 22), (0xfffff0, 24), (0x1fffdf, 21), (0x3fffdf, 22), (0x7fffeb, 23), (0x7fffec, 23),
+    (0x1fffe0, 21), (0x1fffe1, 21), (0x3fffe0, 22), (0x1fffe2, 21), (0x7fffed, 23), (0x3fffe1, 22), (0x7fffee, 23), (0x7fffef, 23),
+    (0xfffea, 20), (0x3fffe2, 22), (0x3fffe3, 22), (0x3fffe4, 22), (0x7ffff0, 23), (0x3fffe5, 22), (0x3fffe6, 22), (0x7ffff1, 23),
+    (0x3ffffe0, 26), (0x3ffffe1, 26), (0xfffeb, 20), (0x7fff1, 19), (0x3fffe7, 22), (0x7ffff2, 23), (0x3fffe8, 22), (0x1ffffec, 25),
+    (0x3ffffe2, 26), (0x3ffffe3, 26), (0x3ffffe4, 26), (0x7ffffde, 27), (0x7ffffdf, 27), (0x3ffffe5, 26), (0xfffff1, 24), (0x1ffffed, 25),
+    (0x7fff2, 19), (0x1fffe3, 21), (0x3ffffe6, 26), (0x7ffffe0, 27), (0x7ffffe1, 27), (0x3ffffe7, 26), (0x7ffffe2, 27), (0xfffff2, 24),
+    (0x1fffe4, 21), (0x1fffe5, 21), (0x3ffffe8, 26), (0x3ffffe9, 26), (0xffffffd, 28), (0x7ffffe3, 27), (0x7ffffe4, 27), (0x7ffffe5, 27),
+    (0xfffec, 20), (0xfffff3, 24), (0xfffed, 20), (0x1fffe6, 21), (0x3fffe9, 22), (0x1fffe7, 21), (0x1fffe8, 21), (0x7ffff3, 23),
+    (0x3fffea, 22), (0x3fffeb, 22), (0x1ffffee, 25), (0x1ffffef, 25), (0xfffff4, 24), (0xfffff5, 24), (0x3ffffea, 26), (0x7ffff4, 23),
+    (0x3ffffeb, 26), (0x7ffffe6, 27), (0x3ffffec, 26), (0x3ffffed, 26), (0x7ffffe7, 27), (0x7ffffe8, 27), (0x7ffffe9, 27), (0x7ffffea, 27),
+    (0x7ffffeb, 27), (0xffffffe, 28), (0x7ffffec, 27), (0x7ffffed, 27), (0x7ffffee, 27), (0x7ffffef, 27), (0x7fffff0, 27), (0x3ffffee, 26),
+    (0x3fffffff, 30),
+)