bemaniutils/bemani/common/card.py

from typing import Dict, List
from typing_extensions import Final


class CardCipherException(Exception):
    pass


class CardCipher:
    """
    Algorithm for converting between the Card ID as stored in an
    eAmusement card and the 16 character card string as shown on
    the back of a card and in-game. All of this was kindly RE'd by
    Tau and converted ham-fistedly to Python.
    """

    KEY: Final[List[int]] = [
        0x20D0D03C,
        0x868ECB41,
        0xBCD89C84,
        0x4C0E0D0D,
        0x84FC30AC,
        0x4CC1890E,
        0xFC5418A4,
        0x02C50F44,
        0x68ACB4E0,
        0x06CD4A4E,
        0xCC28906C,
        0x4F0C8AC0,
        0xB03CA468,
        0x884AC7C4,
        0x389490D8,
        0xCF80C6C2,
        0x58D87404,
        0xC48EC444,
        0xB4E83C50,
        0x498D0147,
        0x64F454C0,
        0x4C4701C8,
        0xEC302CC4,
        0xC6C949C1,
        0xC84C00F0,
        0xCDCC49CC,
        0x883C5CF4,
        0x8B0FCB80,
        0x703CC0B0,
        0xCB820A8D,
        0x78804C8C,
        0x4FCA830E,
        0x80D0F03C,
        0x8EC84F8C,
        0x98C89C4C,
        0xC80D878F,
        0x54BC949C,
        0xC801C5CE,
        0x749078DC,
        0xC3C80D46,
        0x2C8070F0,
        0x0CCE4DCF,
        0x8C3874E4,
        0x8D448AC3,
        0x987CAC70,
        0xC0C20AC5,
        0x288CFC78,
        0xC28543C8,
        0x4C8C7434,
        0xC50E4F8D,
        0x8468F4B4,
        0xCB4A0307,
        0x2854DC98,
        0x48430B45,
        0x6858FCE8,
        0x4681CD49,
        0xD04808EC,
        0x458D0FCB,
        0xE0A48CE4,
        0x880F8FCE,
        0x7434B8FC,
        0xCE080A8E,
        0x5860FC6C,
        0x46C886CC,
        0xD01098A4,
        0xCE090B8C,
        0x1044CC2C,
        0x86898E0F,
        0xD0809C3C,
        0x4A05860F,
        0x54B4F80C,
        0x4008870E,
        0x1480B88C,
        0x0AC8854F,
        0x1C9034CC,
        0x08444C4E,
        0x0CB83C64,
        0x41C08CC6,
        0x1C083460,
        0xC0C603CE,
        0x2CA0645C,
        0x818246CB,
        0x0408E454,
        0xC5464487,
        0x88607C18,
        0xC1424187,
        0x284C7C90,
        0xC1030509,
        0x40486C94,
        0x4603494B,
        0xE0404CE4,
        0x4109094D,
        0x60443CE4,
        0x4C0B8B8D,
        0xE054E8BC,
        0x02008E89,
    ]

    LUT_A0: Final[List[int]] = [
        0x02080008,
        0x02082000,
        0x00002008,
        0x00000000,
        0x02002000,
        0x00080008,
        0x02080000,
        0x02082008,
        0x00000008,
        0x02000000,
        0x00082000,
        0x00002008,
        0x00082008,
        0x02002008,
        0x02000008,
        0x02080000,
        0x00002000,
        0x00082008,
        0x00080008,
        0x02002000,
        0x02082008,
        0x02000008,
        0x00000000,
        0x00082000,
        0x02000000,
        0x00080000,
        0x02002008,
        0x02080008,
        0x00080000,
        0x00002000,
        0x02082000,
        0x00000008,
        0x00080000,
        0x00002000,
        0x02000008,
        0x02082008,
        0x00002008,
        0x02000000,
        0x00000000,
        0x00082000,
        0x02080008,
        0x02002008,
        0x02002000,
        0x00080008,
        0x02082000,
        0x00000008,
        0x00080008,
        0x02002000,
        0x02082008,
        0x00080000,
        0x02080000,
        0x02000008,
        0x00082000,
        0x00002008,
        0x02002008,
        0x02080000,
        0x00000008,
        0x02082000,
        0x00082008,
        0x00000000,
        0x02000000,
        0x02080008,
        0x00002000,
        0x00082008,
    ]

    LUT_A1: Final[List[int]] = [
        0x08000004,
        0x00020004,
        0x00000000,
        0x08020200,
        0x00020004,
        0x00000200,
        0x08000204,
        0x00020000,
        0x00000204,
        0x08020204,
        0x00020200,
        0x08000000,
        0x08000200,
        0x08000004,
        0x08020000,
        0x00020204,
        0x00020000,
        0x08000204,
        0x08020004,
        0x00000000,
        0x00000200,
        0x00000004,
        0x08020200,
        0x08020004,
        0x08020204,
        0x08020000,
        0x08000000,
        0x00000204,
        0x00000004,
        0x00020200,
        0x00020204,
        0x08000200,
        0x00000204,
        0x08000000,
        0x08000200,
        0x00020204,
        0x08020200,
        0x00020004,
        0x00000000,
        0x08000200,
        0x08000000,
        0x00000200,
        0x08020004,
        0x00020000,
        0x00020004,
        0x08020204,
        0x00020200,
        0x00000004,
        0x08020204,
        0x00020200,
        0x00020000,
        0x08000204,
        0x08000004,
        0x08020000,
        0x00020204,
        0x00000000,
        0x00000200,
        0x08000004,
        0x08000204,
        0x08020200,
        0x08020000,
        0x00000204,
        0x00000004,
        0x08020004,
    ]

    LUT_A2: Final[List[int]] = [
        0x80040100,
        0x01000100,
        0x80000000,
        0x81040100,
        0x00000000,
        0x01040000,
        0x81000100,
        0x80040000,
        0x01040100,
        0x81000000,
        0x01000000,
        0x80000100,
        0x81000000,
        0x80040100,
        0x00040000,
        0x01000000,
        0x81040000,
        0x00040100,
        0x00000100,
        0x80000000,
        0x00040100,
        0x81000100,
        0x01040000,
        0x00000100,
        0x80000100,
        0x00000000,
        0x80040000,
        0x01040100,
        0x01000100,
        0x81040000,
        0x81040100,
        0x00040000,
        0x81040000,
        0x80000100,
        0x00040000,
        0x81000000,
        0x00040100,
        0x01000100,
        0x80000000,
        0x01040000,
        0x81000100,
        0x00000000,
        0x00000100,
        0x80040000,
        0x00000000,
        0x81040000,
        0x01040100,
        0x00000100,
        0x01000000,
        0x81040100,
        0x80040100,
        0x00040000,
        0x81040100,
        0x80000000,
        0x01000100,
        0x80040100,
        0x80040000,
        0x00040100,
        0x01040000,
        0x81000100,
        0x80000100,
        0x01000000,
        0x81000000,
        0x01040100,
    ]

    LUT_A3: Final[List[int]] = [
        0x04010801,
        0x00000000,
        0x00010800,
        0x04010000,
        0x04000001,
        0x00000801,
        0x04000800,
        0x00010800,
        0x00000800,
        0x04010001,
        0x00000001,
        0x04000800,
        0x00010001,
        0x04010800,
        0x04010000,
        0x00000001,
        0x00010000,
        0x04000801,
        0x04010001,
        0x00000800,
        0x00010801,
        0x04000000,
        0x00000000,
        0x00010001,
        0x04000801,
        0x00010801,
        0x04010800,
        0x04000001,
        0x04000000,
        0x00010000,
        0x00000801,
        0x04010801,
        0x00010001,
        0x04010800,
        0x04000800,
        0x00010801,
        0x04010801,
        0x00010001,
        0x04000001,
        0x00000000,
        0x04000000,
        0x00000801,
        0x00010000,
        0x04010001,
        0x00000800,
        0x04000000,
        0x00010801,
        0x04000801,
        0x04010800,
        0x00000800,
        0x00000000,
        0x04000001,
        0x00000001,
        0x04010801,
        0x00010800,
        0x04010000,
        0x04010001,
        0x00010000,
        0x00000801,
        0x04000800,
        0x04000801,
        0x00000001,
        0x04010000,
        0x00010800,
    ]

    LUT_B0: Final[List[int]] = [
        0x00000400,
        0x00000020,
        0x00100020,
        0x40100000,
        0x40100420,
        0x40000400,
        0x00000420,
        0x00000000,
        0x00100000,
        0x40100020,
        0x40000020,
        0x00100400,
        0x40000000,
        0x00100420,
        0x00100400,
        0x40000020,
        0x40100020,
        0x00000400,
        0x40000400,
        0x40100420,
        0x00000000,
        0x00100020,
        0x40100000,
        0x00000420,
        0x40100400,
        0x40000420,
        0x00100420,
        0x40000000,
        0x40000420,
        0x40100400,
        0x00000020,
        0x00100000,
        0x40000420,
        0x00100400,
        0x40100400,
        0x40000020,
        0x00000400,
        0x00000020,
        0x00100000,
        0x40100400,
        0x40100020,
        0x40000420,
        0x00000420,
        0x00000000,
        0x00000020,
        0x40100000,
        0x40000000,
        0x00100020,
        0x00000000,
        0x40100020,
        0x00100020,
        0x00000420,
        0x40000020,
        0x00000400,
        0x40100420,
        0x00100000,
        0x00100420,
        0x40000000,
        0x40000400,
        0x40100420,
        0x40100000,
        0x00100420,
        0x00100400,
        0x40000400,
    ]

    LUT_B1: Final[List[int]] = [
        0x00800000,
        0x00001000,
        0x00000040,
        0x00801042,
        0x00801002,
        0x00800040,
        0x00001042,
        0x00801000,
        0x00001000,
        0x00000002,
        0x00800002,
        0x00001040,
        0x00800042,
        0x00801002,
        0x00801040,
        0x00000000,
        0x00001040,
        0x00800000,
        0x00001002,
        0x00000042,
        0x00800040,
        0x00001042,
        0x00000000,
        0x00800002,
        0x00000002,
        0x00800042,
        0x00801042,
        0x00001002,
        0x00801000,
        0x00000040,
        0x00000042,
        0x00801040,
        0x00801040,
        0x00800042,
        0x00001002,
        0x00801000,
        0x00001000,
        0x00000002,
        0x00800002,
        0x00800040,
        0x00800000,
        0x00001040,
        0x00801042,
        0x00000000,
        0x00001042,
        0x00800000,
        0x00000040,
        0x00001002,
        0x00800042,
        0x00000040,
        0x00000000,
        0x00801042,
        0x00801002,
        0x00801040,
        0x00000042,
        0x00001000,
        0x00001040,
        0x00801002,
        0x00800040,
        0x00000042,
        0x00000002,
        0x00001042,
        0x00801000,
        0x00800002,
    ]

    LUT_B2: Final[List[int]] = [
        0x10400000,
        0x00404010,
        0x00000010,
        0x10400010,
        0x10004000,
        0x00400000,
        0x10400010,
        0x00004010,
        0x00400010,
        0x00004000,
        0x00404000,
        0x10000000,
        0x10404010,
        0x10000010,
        0x10000000,
        0x10404000,
        0x00000000,
        0x10004000,
        0x00404010,
        0x00000010,
        0x10000010,
        0x10404010,
        0x00004000,
        0x10400000,
        0x10404000,
        0x00400010,
        0x10004010,
        0x00404000,
        0x00004010,
        0x00000000,
        0x00400000,
        0x10004010,
        0x00404010,
        0x00000010,
        0x10000000,
        0x00004000,
        0x10000010,
        0x10004000,
        0x00404000,
        0x10400010,
        0x00000000,
        0x00404010,
        0x00004010,
        0x10404000,
        0x10004000,
        0x00400000,
        0x10404010,
        0x10000000,
        0x10004010,
        0x10400000,
        0x00400000,
        0x10404010,
        0x00004000,
        0x00400010,
        0x10400010,
        0x00004010,
        0x00400010,
        0x00000000,
        0x10404000,
        0x10000010,
        0x10400000,
        0x10004010,
        0x00000010,
        0x00404000,
    ]

    LUT_B3: Final[List[int]] = [
        0x00208080,
        0x00008000,
        0x20200000,
        0x20208080,
        0x00200000,
        0x20008080,
        0x20008000,
        0x20200000,
        0x20008080,
        0x00208080,
        0x00208000,
        0x20000080,
        0x20200080,
        0x00200000,
        0x00000000,
        0x20008000,
        0x00008000,
        0x20000000,
        0x00200080,
        0x00008080,
        0x20208080,
        0x00208000,
        0x20000080,
        0x00200080,
        0x20000000,
        0x00000080,
        0x00008080,
        0x20208000,
        0x00000080,
        0x20200080,
        0x20208000,
        0x00000000,
        0x00000000,
        0x20208080,
        0x00200080,
        0x20008000,
        0x00208080,
        0x00008000,
        0x20000080,
        0x00200080,
        0x20208000,
        0x00000080,
        0x00008080,
        0x20200000,
        0x20008080,
        0x20000000,
        0x20200000,
        0x00208000,
        0x20208080,
        0x00008080,
        0x00208000,
        0x20200080,
        0x00200000,
        0x20000080,
        0x20008000,
        0x00000000,
        0x00008000,
        0x00200000,
        0x20200080,
        0x00208080,
        0x20000000,
        0x20208000,
        0x00000080,
        0x20008080,
    ]

    VALID_CHARS: Final[str] = "0123456789ABCDEFGHJKLMNPRSTUWXYZ"
    CONV_CHARS: Final[Dict[str, str]] = {
        "I": "1",
        "O": "0",
    }

    @staticmethod
    def __type_from_cardid(cardid: str) -> int:
        if cardid[:2].upper() == "E0":
            return 1
        if cardid[:2].upper() == "01":
            return 2
        raise CardCipherException("Unrecognized card type")

    @staticmethod
    def encode(cardid: str) -> str:
        """
        Given a card ID as stored on a card (Usually starting with E004), convert
        it to the card string as shown on the back of the card.

        Parameters:
            cardid - 16 digit card ID (hex values stored as string).

        Returns:
            String representation of the card string.
        """
        if len(cardid) != 16:
            raise CardCipherException(
                f"Expected 16-character card ID, got {len(cardid)}",
            )

        cardint = [int(cardid[i : (i + 2)], 16) for i in range(0, len(cardid), 2)]

        # Reverse bytes
        reverse = [0] * 8
        for i in range(0, 8):
            reverse[7 - i] = cardint[i]

        # Encipher
        ciphered = CardCipher._encode(bytes(reverse))

        # Convert 8 x 8 bit bytes into 13 x 5 bit groups (sort of)
        bits = [0] * 65
        for i in range(0, 64):
            bits[i] = (ciphered[i >> 3] >> (~i & 7)) & 1

        groups = [0] * 16
        for i in range(0, 13):
            groups[i] = (
                (bits[i * 5 + 0] << 4)
                | (bits[i * 5 + 1] << 3)
                | (bits[i * 5 + 2] << 2)
                | (bits[i * 5 + 3] << 1)
                | (bits[i * 5 + 4] << 0)
            )

        # Smear 13 groups out into 14 groups
        groups[13] = 1
        groups[0] ^= CardCipher.__type_from_cardid(cardid)

        for i in range(0, 14):
            groups[i] ^= groups[i - 1]

        # Scheme field is 1 for old-style, 2 for felica cards
        groups[14] = CardCipher.__type_from_cardid(cardid)
        groups[15] = CardCipher.__checksum(groups)

        # Convert to chars and return
        return "".join([CardCipher.VALID_CHARS[i] for i in groups])

    @staticmethod
    def decode(cardid: str) -> str:
        """
        Given a card string as shown on the back of the card, return the card ID
        as stored on the card itself. Does some sanitization to remove dashes,
        spaces and convert confusing characters (1, L and 0, O) before converting.

        Parameters:
            cardid - String representation of the card string.

        Returns:
            16 digit card ID (hex values stored as string).
        """
        # First sanitize the input
        cardid = cardid.replace(" ", "")
        cardid = cardid.replace("-", "")
        cardid = cardid.upper()
        for c in CardCipher.CONV_CHARS:
            cardid = cardid.replace(c, CardCipher.CONV_CHARS[c])

        if len(cardid) != 16:
            raise CardCipherException(
                f"Expected 16-character card ID, got {len(cardid)}",
            )

        for c in cardid:
            if c not in CardCipher.VALID_CHARS:
                raise CardCipherException(
                    f"Got unexpected character {c} in card ID",
                )

        # Convert chars to groups
        groups = [0] * 16

        for i in range(0, 16):
            for j in range(0, 32):
                if cardid[i] == CardCipher.VALID_CHARS[j]:
                    groups[i] = j
                    break

        # Verify scheme and checksum
        if groups[14] != 1 and groups[14] != 2:
            raise CardCipherException("Unrecognized card type")
        if groups[15] != CardCipher.__checksum(groups):
            raise CardCipherException("Bad card number")

        # Un-smear 14 fields back into 13
        for i in range(13, 0, -1):
            groups[i] ^= groups[i - 1]
        groups[0] ^= groups[14]

        # Explode groups into bits
        bits = [0] * 64

        for i in range(0, 64):
            bits[i] = (groups[int(i / 5)] >> (4 - (i % 5))) & 1

        # Re-pack bits into eight bytes
        ciphered = [0] * 8

        for i in range(0, 64):
            ciphered[int(i / 8)] |= bits[i] << (~i & 7)

        # Decipher and reverse
        deciphered = CardCipher._decode(bytes(ciphered))
        reverse = [0] * 8
        for i in range(0, 8):
            reverse[i] = deciphered[7 - i]

        def tohex(x: int) -> str:
            h = hex(x)[2:]
            while len(h) < 2:
                h = "0" + h
            return h.upper()

        # Convert to a string, verify we have the same type
        finalvalue = "".join([tohex(v) for v in reverse])
        if groups[14] != CardCipher.__type_from_cardid(finalvalue):
            raise CardCipherException("Card type mismatch")
        return finalvalue

    @staticmethod
    def __checksum(data: List[int]) -> int:
        checksum = 0

        for i in range(0, 15):
            checksum += (i % 3 + 1) * data[i]

        while checksum >= 0x20:
            checksum = (checksum & 0x1F) + (checksum >> 5)

        return checksum

    @staticmethod
    def _encode(inbytes: bytes) -> bytes:
        if len(inbytes) != 8:
            raise CardCipherException(
                f"Expected 8-byte input, got {len(inbytes)}",
            )

        inp = [b for b in inbytes]
        out = [0] * 8

        CardCipher.__from_int(
            out, CardCipher.__operatorA(0x00, CardCipher.__to_int(inp))
        )
        CardCipher.__from_int(
            out, CardCipher.__operatorB(0x20, CardCipher.__to_int(out))
        )
        CardCipher.__from_int(
            out, CardCipher.__operatorA(0x40, CardCipher.__to_int(out))
        )

        return bytes(out)

    @staticmethod
    def _decode(inbytes: bytes) -> bytes:
        if len(inbytes) != 8:
            raise CardCipherException(
                f"Expected 8-byte input, got {len(inbytes)}",
            )

        inp = [b for b in inbytes]
        out = [0] * 8

        CardCipher.__from_int(
            out, CardCipher.__operatorB(0x40, CardCipher.__to_int(inp))
        )
        CardCipher.__from_int(
            out, CardCipher.__operatorA(0x20, CardCipher.__to_int(out))
        )
        CardCipher.__from_int(
            out, CardCipher.__operatorB(0x00, CardCipher.__to_int(out))
        )

        return bytes(out)

    @staticmethod
    def __to_int(data: List[int]) -> int:
        inX = (
            (data[0] & 0xFF)
            | ((data[1] & 0xFF) << 8)
            | ((data[2] & 0xFF) << 16)
            | ((data[3] & 0xFF) << 24)
        )

        inY = (
            (data[4] & 0xFF)
            | ((data[5] & 0xFF) << 8)
            | ((data[6] & 0xFF) << 16)
            | ((data[7] & 0xFF) << 24)
        )

        v7 = ((((inX ^ (inY >> 4)) & 0xF0F0F0F) << 4) ^ inY) & 0xFFFFFFFF
        v8 = (((inX ^ (inY >> 4)) & 0xF0F0F0F) ^ inX) & 0xFFFFFFFF

        v9 = ((v7 ^ (v8 >> 16))) & 0x0000FFFF
        v10 = (((v7 ^ (v8 >> 16)) << 16) ^ v8) & 0xFFFFFFFF

        v11 = (v9 ^ v7) & 0xFFFFFFFF
        v12 = (v10 ^ (v11 >> 2)) & 0x33333333
        v13 = (v11 ^ (v12 << 2)) & 0xFFFFFFFF

        v14 = (v12 ^ v10) & 0xFFFFFFFF
        v15 = (v13 ^ (v14 >> 8)) & 0x00FF00FF
        v16 = (v14 ^ (v15 << 8)) & 0xFFFFFFFF

        v17 = CardCipher.__ror(v15 ^ v13, 1)
        v18 = (v16 ^ v17) & 0x55555555

        v3 = CardCipher.__ror(v18 ^ v16, 1)
        v4 = (v18 ^ v17) & 0xFFFFFFFF

        return ((v3 & 0xFFFFFFFF) << 32) | (v4 & 0xFFFFFFFF)

    @staticmethod
    def __from_int(data: List[int], state: int) -> None:
        v3 = (state >> 32) & 0xFFFFFFFF
        v4 = state & 0xFFFFFFFF

        v22 = CardCipher.__ror(v4, 31)
        v23 = (v3 ^ v22) & 0x55555555
        v24 = (v23 ^ v22) & 0xFFFFFFFF

        v25 = CardCipher.__ror(v23 ^ v3, 31)
        v26 = (v25 ^ (v24 >> 8)) & 0x00FF00FF
        v27 = (v24 ^ (v26 << 8)) & 0xFFFFFFFF

        v28 = (v26 ^ v25) & 0xFFFFFFFF
        v29 = ((v28 >> 2) ^ v27) & 0x33333333
        v30 = ((v29 << 2) ^ v28) & 0xFFFFFFFF

        v31 = (v29 ^ v27) & 0xFFFFFFFF
        v32 = (v30 ^ (v31 >> 16)) & 0x0000FFFF
        v33 = (v31 ^ (v32 << 16)) & 0xFFFFFFFF

        v34 = (v32 ^ v30) & 0xFFFFFFFF
        v35 = (v33 ^ (v34 >> 4)) & 0xF0F0F0F

        outY = ((v35 << 4) ^ v34) & 0xFFFFFFFF
        outX = (v35 ^ v33) & 0xFFFFFFFF

        data[0] = outX & 0xFF
        data[1] = (outX >> 8) & 0xFF
        data[2] = (outX >> 16) & 0xFF
        data[3] = (outX >> 24) & 0xFF
        data[4] = outY & 0xFF
        data[5] = (outY >> 8) & 0xFF
        data[6] = (outY >> 16) & 0xFF
        data[7] = (outY >> 24) & 0xFF

    @staticmethod
    def __operatorA(off: int, state: int) -> int:
        v3 = (state >> 32) & 0xFFFFFFFF
        v4 = state & 0xFFFFFFFF

        for i in range(0, 32, 4):
            v20 = CardCipher.__ror(v3 ^ CardCipher.KEY[off + i + 1], 28)

            v4 ^= (
                CardCipher.LUT_B0[(v20 >> 26) & 0x3F]
                ^ CardCipher.LUT_B1[(v20 >> 18) & 0x3F]
                ^ CardCipher.LUT_B2[(v20 >> 10) & 0x3F]
                ^ CardCipher.LUT_B3[(v20 >> 2) & 0x3F]
                ^ CardCipher.LUT_A0[((v3 ^ CardCipher.KEY[off + i]) >> 26) & 0x3F]
                ^ CardCipher.LUT_A1[((v3 ^ CardCipher.KEY[off + i]) >> 18) & 0x3F]
                ^ CardCipher.LUT_A2[((v3 ^ CardCipher.KEY[off + i]) >> 10) & 0x3F]
                ^ CardCipher.LUT_A3[((v3 ^ CardCipher.KEY[off + i]) >> 2) & 0x3F]
            )

            v21 = CardCipher.__ror(v4 ^ CardCipher.KEY[off + i + 3], 28)

            v3 ^= (
                CardCipher.LUT_B0[(v21 >> 26) & 0x3F]
                ^ CardCipher.LUT_B1[(v21 >> 18) & 0x3F]
                ^ CardCipher.LUT_B2[(v21 >> 10) & 0x3F]
                ^ CardCipher.LUT_B3[(v21 >> 2) & 0x3F]
                ^ CardCipher.LUT_A0[((v4 ^ CardCipher.KEY[off + i + 2]) >> 26) & 0x3F]
                ^ CardCipher.LUT_A1[((v4 ^ CardCipher.KEY[off + i + 2]) >> 18) & 0x3F]
                ^ CardCipher.LUT_A2[((v4 ^ CardCipher.KEY[off + i + 2]) >> 10) & 0x3F]
                ^ CardCipher.LUT_A3[((v4 ^ CardCipher.KEY[off + i + 2]) >> 2) & 0x3F]
            )

        return ((v3 & 0xFFFFFFFF) << 32) | (v4 & 0xFFFFFFFF)

    @staticmethod
    def __operatorB(off: int, state: int) -> int:
        v3 = (state >> 32) & 0xFFFFFFFF
        v4 = state & 0xFFFFFFFF

        for i in range(0, 32, 4):
            v20 = CardCipher.__ror(v3 ^ CardCipher.KEY[off + 31 - i], 28)

            v4 ^= (
                CardCipher.LUT_A0[((v3 ^ CardCipher.KEY[off + 30 - i]) >> 26) & 0x3F]
                ^ CardCipher.LUT_A1[((v3 ^ CardCipher.KEY[off + 30 - i]) >> 18) & 0x3F]
                ^ CardCipher.LUT_A2[((v3 ^ CardCipher.KEY[off + 30 - i]) >> 10) & 0x3F]
                ^ CardCipher.LUT_A3[((v3 ^ CardCipher.KEY[off + 30 - i]) >> 2) & 0x3F]
                ^ CardCipher.LUT_B0[(v20 >> 26) & 0x3F]
                ^ CardCipher.LUT_B1[(v20 >> 18) & 0x3F]
                ^ CardCipher.LUT_B2[(v20 >> 10) & 0x3F]
                ^ CardCipher.LUT_B3[(v20 >> 2) & 0x3F]
            )

            v21 = CardCipher.__ror(v4 ^ CardCipher.KEY[off + 29 - i], 28)

            v3 ^= (
                CardCipher.LUT_A0[((v4 ^ CardCipher.KEY[off + 28 - i]) >> 26) & 0x3F]
                ^ CardCipher.LUT_A1[((v4 ^ CardCipher.KEY[off + 28 - i]) >> 18) & 0x3F]
                ^ CardCipher.LUT_A2[((v4 ^ CardCipher.KEY[off + 28 - i]) >> 10) & 0x3F]
                ^ CardCipher.LUT_A3[((v4 ^ CardCipher.KEY[off + 28 - i]) >> 2) & 0x3F]
                ^ CardCipher.LUT_B0[(v21 >> 26) & 0x3F]
                ^ CardCipher.LUT_B1[(v21 >> 18) & 0x3F]
                ^ CardCipher.LUT_B2[(v21 >> 10) & 0x3F]
                ^ CardCipher.LUT_B3[(v21 >> 2) & 0x3F]
            )

        return ((v3 & 0xFFFFFFFF) << 32) | (v4 & 0xFFFFFFFF)

    @staticmethod
    def __ror(val: int, amount: int) -> int:
        return ((val << (32 - amount)) & 0xFFFFFFFF) | ((val >> amount) & 0xFFFFFFFF)