polyfile-weave 0.5.5__py3-none-any.whl

polyfile/kaitai/parsers/udp_datagram.py

@@ -0,0 +1,42 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class UdpDatagram(KaitaiStruct):
+    """UDP is a simple stateless transport layer (AKA OSI layer 4)
+    protocol, one of the core Internet protocols. It provides source and
+    destination ports, basic checksumming, but provides not guarantees
+    of delivery, order of packets, or duplicate delivery.
+    """
+    SEQ_FIELDS = ["src_port", "dst_port", "length", "checksum", "body"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['src_port']['start'] = self._io.pos()
+        self.src_port = self._io.read_u2be()
+        self._debug['src_port']['end'] = self._io.pos()
+        self._debug['dst_port']['start'] = self._io.pos()
+        self.dst_port = self._io.read_u2be()
+        self._debug['dst_port']['end'] = self._io.pos()
+        self._debug['length']['start'] = self._io.pos()
+        self.length = self._io.read_u2be()
+        self._debug['length']['end'] = self._io.pos()
+        self._debug['checksum']['start'] = self._io.pos()
+        self.checksum = self._io.read_u2be()
+        self._debug['checksum']['end'] = self._io.pos()
+        self._debug['body']['start'] = self._io.pos()
+        self.body = self._io.read_bytes((self.length - 8))
+        self._debug['body']['end'] = self._io.pos()
+
+

polyfile/kaitai/parsers/uefi_te.py

@@ -0,0 +1,236 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+import collections
+from enum import Enum
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class UefiTe(KaitaiStruct):
+    """This type of executables could be found inside the UEFI firmware. The UEFI
+    firmware is stored in SPI flash memory, which is a chip soldered on a
+    system's motherboard. UEFI firmware is very modular: it usually contains
+    dozens, if not hundreds, of executables. To store all these separates files,
+    the firmware is laid out in volumes using the Firmware File System (FFS), a
+    file system specifically designed to store firmware images. The volumes
+    contain files that are identified by GUIDs and each of these files contain
+    one or more sections holding the data. One of these sections contains the
+    actual executable image. Most of the executable images follow the PE format.
+    However, some of them follow the TE format.
+    
+    The Terse Executable (TE) image format was created as a mechanism to reduce
+    the overhead of the PE/COFF headers in PE32/PE32+ images, resulting in a
+    corresponding reduction of image sizes for executables running in the PI
+    (Platform Initialization) Architecture environment. Reducing image size
+    provides an opportunity for use of a smaller system flash part.
+    
+    So the TE format is basically a stripped version of PE.
+    
+    .. seealso::
+       Source - https://uefi.org/sites/default/files/resources/PI_Spec_1_6.pdf
+    """
+    SEQ_FIELDS = ["te_hdr", "sections"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['te_hdr']['start'] = self._io.pos()
+        self._raw_te_hdr = self._io.read_bytes(40)
+        _io__raw_te_hdr = KaitaiStream(BytesIO(self._raw_te_hdr))
+        self.te_hdr = UefiTe.TeHeader(_io__raw_te_hdr, self, self._root)
+        self.te_hdr._read()
+        self._debug['te_hdr']['end'] = self._io.pos()
+        self._debug['sections']['start'] = self._io.pos()
+        self.sections = [None] * (self.te_hdr.num_sections)
+        for i in range(self.te_hdr.num_sections):
+            if not 'arr' in self._debug['sections']:
+                self._debug['sections']['arr'] = []
+            self._debug['sections']['arr'].append({'start': self._io.pos()})
+            _t_sections = UefiTe.Section(self._io, self, self._root)
+            _t_sections._read()
+            self.sections[i] = _t_sections
+            self._debug['sections']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['sections']['end'] = self._io.pos()
+
+    class TeHeader(KaitaiStruct):
+
+        class MachineType(Enum):
+            unknown = 0
+            i386 = 332
+            r4000 = 358
+            wcemipsv2 = 361
+            alpha = 388
+            sh3 = 418
+            sh3dsp = 419
+            sh4 = 422
+            sh5 = 424
+            arm = 448
+            thumb = 450
+            armnt = 452
+            am33 = 467
+            powerpc = 496
+            powerpcfp = 497
+            ia64 = 512
+            mips16 = 614
+            mipsfpu = 870
+            mipsfpu16 = 1126
+            ebc = 3772
+            riscv32 = 20530
+            riscv64 = 20580
+            riscv128 = 20776
+            amd64 = 34404
+            m32r = 36929
+            arm64 = 43620
+
+        class SubsystemEnum(Enum):
+            unknown = 0
+            native = 1
+            windows_gui = 2
+            windows_cui = 3
+            posix_cui = 7
+            windows_ce_gui = 9
+            efi_application = 10
+            efi_boot_service_driver = 11
+            efi_runtime_driver = 12
+            efi_rom = 13
+            xbox = 14
+            windows_boot_application = 16
+        SEQ_FIELDS = ["magic", "machine", "num_sections", "subsystem", "stripped_size", "entry_point_addr", "base_of_code", "image_base", "data_dirs"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['magic']['start'] = self._io.pos()
+            self.magic = self._io.read_bytes(2)
+            self._debug['magic']['end'] = self._io.pos()
+            if not self.magic == b"\x56\x5A":
+                raise kaitaistruct.ValidationNotEqualError(b"\x56\x5A", self.magic, self._io, u"/types/te_header/seq/0")
+            self._debug['machine']['start'] = self._io.pos()
+            self.machine = KaitaiStream.resolve_enum(UefiTe.TeHeader.MachineType, self._io.read_u2le())
+            self._debug['machine']['end'] = self._io.pos()
+            self._debug['num_sections']['start'] = self._io.pos()
+            self.num_sections = self._io.read_u1()
+            self._debug['num_sections']['end'] = self._io.pos()
+            self._debug['subsystem']['start'] = self._io.pos()
+            self.subsystem = KaitaiStream.resolve_enum(UefiTe.TeHeader.SubsystemEnum, self._io.read_u1())
+            self._debug['subsystem']['end'] = self._io.pos()
+            self._debug['stripped_size']['start'] = self._io.pos()
+            self.stripped_size = self._io.read_u2le()
+            self._debug['stripped_size']['end'] = self._io.pos()
+            self._debug['entry_point_addr']['start'] = self._io.pos()
+            self.entry_point_addr = self._io.read_u4le()
+            self._debug['entry_point_addr']['end'] = self._io.pos()
+            self._debug['base_of_code']['start'] = self._io.pos()
+            self.base_of_code = self._io.read_u4le()
+            self._debug['base_of_code']['end'] = self._io.pos()
+            self._debug['image_base']['start'] = self._io.pos()
+            self.image_base = self._io.read_u8le()
+            self._debug['image_base']['end'] = self._io.pos()
+            self._debug['data_dirs']['start'] = self._io.pos()
+            self.data_dirs = UefiTe.HeaderDataDirs(self._io, self, self._root)
+            self.data_dirs._read()
+            self._debug['data_dirs']['end'] = self._io.pos()
+
+
+    class HeaderDataDirs(KaitaiStruct):
+        SEQ_FIELDS = ["base_relocation_table", "debug"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['base_relocation_table']['start'] = self._io.pos()
+            self.base_relocation_table = UefiTe.DataDir(self._io, self, self._root)
+            self.base_relocation_table._read()
+            self._debug['base_relocation_table']['end'] = self._io.pos()
+            self._debug['debug']['start'] = self._io.pos()
+            self.debug = UefiTe.DataDir(self._io, self, self._root)
+            self.debug._read()
+            self._debug['debug']['end'] = self._io.pos()
+
+
+    class DataDir(KaitaiStruct):
+        SEQ_FIELDS = ["virtual_address", "size"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['virtual_address']['start'] = self._io.pos()
+            self.virtual_address = self._io.read_u4le()
+            self._debug['virtual_address']['end'] = self._io.pos()
+            self._debug['size']['start'] = self._io.pos()
+            self.size = self._io.read_u4le()
+            self._debug['size']['end'] = self._io.pos()
+
+
+    class Section(KaitaiStruct):
+        SEQ_FIELDS = ["name", "virtual_size", "virtual_address", "size_of_raw_data", "pointer_to_raw_data", "pointer_to_relocations", "pointer_to_linenumbers", "num_relocations", "num_linenumbers", "characteristics"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['name']['start'] = self._io.pos()
+            self.name = (KaitaiStream.bytes_strip_right(self._io.read_bytes(8), 0)).decode(u"UTF-8")
+            self._debug['name']['end'] = self._io.pos()
+            self._debug['virtual_size']['start'] = self._io.pos()
+            self.virtual_size = self._io.read_u4le()
+            self._debug['virtual_size']['end'] = self._io.pos()
+            self._debug['virtual_address']['start'] = self._io.pos()
+            self.virtual_address = self._io.read_u4le()
+            self._debug['virtual_address']['end'] = self._io.pos()
+            self._debug['size_of_raw_data']['start'] = self._io.pos()
+            self.size_of_raw_data = self._io.read_u4le()
+            self._debug['size_of_raw_data']['end'] = self._io.pos()
+            self._debug['pointer_to_raw_data']['start'] = self._io.pos()
+            self.pointer_to_raw_data = self._io.read_u4le()
+            self._debug['pointer_to_raw_data']['end'] = self._io.pos()
+            self._debug['pointer_to_relocations']['start'] = self._io.pos()
+            self.pointer_to_relocations = self._io.read_u4le()
+            self._debug['pointer_to_relocations']['end'] = self._io.pos()
+            self._debug['pointer_to_linenumbers']['start'] = self._io.pos()
+            self.pointer_to_linenumbers = self._io.read_u4le()
+            self._debug['pointer_to_linenumbers']['end'] = self._io.pos()
+            self._debug['num_relocations']['start'] = self._io.pos()
+            self.num_relocations = self._io.read_u2le()
+            self._debug['num_relocations']['end'] = self._io.pos()
+            self._debug['num_linenumbers']['start'] = self._io.pos()
+            self.num_linenumbers = self._io.read_u2le()
+            self._debug['num_linenumbers']['end'] = self._io.pos()
+            self._debug['characteristics']['start'] = self._io.pos()
+            self.characteristics = self._io.read_u4le()
+            self._debug['characteristics']['end'] = self._io.pos()
+
+        @property
+        def body(self):
+            if hasattr(self, '_m_body'):
+                return self._m_body if hasattr(self, '_m_body') else None
+
+            _pos = self._io.pos()
+            self._io.seek(((self.pointer_to_raw_data - self._root.te_hdr.stripped_size) + self._root.te_hdr._io.size()))
+            self._debug['_m_body']['start'] = self._io.pos()
+            self._m_body = self._io.read_bytes(self.size_of_raw_data)
+            self._debug['_m_body']['end'] = self._io.pos()
+            self._io.seek(_pos)
+            return self._m_body if hasattr(self, '_m_body') else None
+
+
+

polyfile/kaitai/parsers/uimage.py

@@ -0,0 +1,198 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+from enum import Enum
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class Uimage(KaitaiStruct):
+    """The new uImage format allows more flexibility in handling images of various
+    types (kernel, ramdisk, etc.), it also enhances integrity protection of images
+    with sha1 and md5 checksums.
+    
+    .. seealso::
+       Source - https://source.denx.de/u-boot/u-boot/-/raw/e4dba4ba6f/include/image.h
+    """
+
+    class UimageOs(Enum):
+        invalid = 0
+        openbsd = 1
+        netbsd = 2
+        freebsd = 3
+        bsd4_4 = 4
+        linux = 5
+        svr4 = 6
+        esix = 7
+        solaris = 8
+        irix = 9
+        sco = 10
+        dell = 11
+        ncr = 12
+        lynxos = 13
+        vxworks = 14
+        psos = 15
+        qnx = 16
+        u_boot = 17
+        rtems = 18
+        artos = 19
+        unity = 20
+        integrity = 21
+        ose = 22
+        plan9 = 23
+        openrtos = 24
+        arm_trusted_firmware = 25
+        tee = 26
+        opensbi = 27
+        efi = 28
+
+    class UimageArch(Enum):
+        invalid = 0
+        alpha = 1
+        arm = 2
+        i386 = 3
+        ia64 = 4
+        mips = 5
+        mips64 = 6
+        ppc = 7
+        s390 = 8
+        sh = 9
+        sparc = 10
+        sparc64 = 11
+        m68k = 12
+        nios = 13
+        microblaze = 14
+        nios2 = 15
+        blackfin = 16
+        avr32 = 17
+        st200 = 18
+        sandbox = 19
+        nds32 = 20
+        openrisc = 21
+        arm64 = 22
+        arc = 23
+        x86_64 = 24
+        xtensa = 25
+        riscv = 26
+
+    class UimageComp(Enum):
+        none = 0
+        gzip = 1
+        bzip2 = 2
+        lzma = 3
+        lzo = 4
+        lz4 = 5
+        zstd = 6
+
+    class UimageType(Enum):
+        invalid = 0
+        standalone = 1
+        kernel = 2
+        ramdisk = 3
+        multi = 4
+        firmware = 5
+        script = 6
+        filesystem = 7
+        flatdt = 8
+        kwbimage = 9
+        imximage = 10
+        ublimage = 11
+        omapimage = 12
+        aisimage = 13
+        kernel_noload = 14
+        pblimage = 15
+        mxsimage = 16
+        gpimage = 17
+        atmelimage = 18
+        socfpgaimage = 19
+        x86_setup = 20
+        lpc32xximage = 21
+        loadable = 22
+        rkimage = 23
+        rksd = 24
+        rkspi = 25
+        zynqimage = 26
+        zynqmpimage = 27
+        zynqmpbif = 28
+        fpga = 29
+        vybridimage = 30
+        tee = 31
+        firmware_ivt = 32
+        pmmc = 33
+        stm32image = 34
+        socfpgaimage_v1 = 35
+        mtkimage = 36
+        imx8mimage = 37
+        imx8image = 38
+        copro = 39
+        sunxi_egon = 40
+    SEQ_FIELDS = ["header", "data"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['header']['start'] = self._io.pos()
+        self.header = Uimage.Uheader(self._io, self, self._root)
+        self.header._read()
+        self._debug['header']['end'] = self._io.pos()
+        self._debug['data']['start'] = self._io.pos()
+        self.data = self._io.read_bytes(self.header.len_image)
+        self._debug['data']['end'] = self._io.pos()
+
+    class Uheader(KaitaiStruct):
+        SEQ_FIELDS = ["magic", "header_crc", "timestamp", "len_image", "load_address", "entry_address", "data_crc", "os_type", "architecture", "image_type", "compression_type", "name"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['magic']['start'] = self._io.pos()
+            self.magic = self._io.read_bytes(4)
+            self._debug['magic']['end'] = self._io.pos()
+            if not self.magic == b"\x27\x05\x19\x56":
+                raise kaitaistruct.ValidationNotEqualError(b"\x27\x05\x19\x56", self.magic, self._io, u"/types/uheader/seq/0")
+            self._debug['header_crc']['start'] = self._io.pos()
+            self.header_crc = self._io.read_u4be()
+            self._debug['header_crc']['end'] = self._io.pos()
+            self._debug['timestamp']['start'] = self._io.pos()
+            self.timestamp = self._io.read_u4be()
+            self._debug['timestamp']['end'] = self._io.pos()
+            self._debug['len_image']['start'] = self._io.pos()
+            self.len_image = self._io.read_u4be()
+            self._debug['len_image']['end'] = self._io.pos()
+            self._debug['load_address']['start'] = self._io.pos()
+            self.load_address = self._io.read_u4be()
+            self._debug['load_address']['end'] = self._io.pos()
+            self._debug['entry_address']['start'] = self._io.pos()
+            self.entry_address = self._io.read_u4be()
+            self._debug['entry_address']['end'] = self._io.pos()
+            self._debug['data_crc']['start'] = self._io.pos()
+            self.data_crc = self._io.read_u4be()
+            self._debug['data_crc']['end'] = self._io.pos()
+            self._debug['os_type']['start'] = self._io.pos()
+            self.os_type = KaitaiStream.resolve_enum(Uimage.UimageOs, self._io.read_u1())
+            self._debug['os_type']['end'] = self._io.pos()
+            self._debug['architecture']['start'] = self._io.pos()
+            self.architecture = KaitaiStream.resolve_enum(Uimage.UimageArch, self._io.read_u1())
+            self._debug['architecture']['end'] = self._io.pos()
+            self._debug['image_type']['start'] = self._io.pos()
+            self.image_type = KaitaiStream.resolve_enum(Uimage.UimageType, self._io.read_u1())
+            self._debug['image_type']['end'] = self._io.pos()
+            self._debug['compression_type']['start'] = self._io.pos()
+            self.compression_type = KaitaiStream.resolve_enum(Uimage.UimageComp, self._io.read_u1())
+            self._debug['compression_type']['end'] = self._io.pos()
+            self._debug['name']['start'] = self._io.pos()
+            self.name = (KaitaiStream.bytes_terminate(self._io.read_bytes(32), 0, False)).decode(u"UTF-8")
+            self._debug['name']['end'] = self._io.pos()
+
+
+

polyfile/kaitai/parsers/utf8_string.py

@@ -0,0 +1,137 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class Utf8String(KaitaiStruct):
+    """UTF-8 is a popular character encoding scheme that allows to
+    represent strings as sequence of code points defined in Unicode
+    standard. Its features are:
+    
+    * variable width (i.e. one code point might be represented by 1 to 4
+      bytes)
+    * backward compatiblity with ASCII
+    * basic validity checking (and thus distinguishing from other legacy
+      8-bit encodings)
+    * maintaining sort order of codepoints if sorted as a byte array
+    
+    WARNING: For the vast majority of practical purposes of format
+    definitions in Kaitai Struct, you'd likely NOT want to use this and
+    rather just use `type: str` with `encoding: utf-8`. That will use
+    native string implementations, which are most likely more efficient
+    and will give you native language strings, rather than an array of
+    individual codepoints.  This format definition is provided mostly
+    for educational / research purposes.
+    """
+    SEQ_FIELDS = ["codepoints"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['codepoints']['start'] = self._io.pos()
+        self.codepoints = []
+        i = 0
+        while not self._io.is_eof():
+            if not 'arr' in self._debug['codepoints']:
+                self._debug['codepoints']['arr'] = []
+            self._debug['codepoints']['arr'].append({'start': self._io.pos()})
+            _t_codepoints = Utf8String.Utf8Codepoint(self._io.pos(), self._io, self, self._root)
+            _t_codepoints._read()
+            self.codepoints.append(_t_codepoints)
+            self._debug['codepoints']['arr'][len(self.codepoints) - 1]['end'] = self._io.pos()
+            i += 1
+
+        self._debug['codepoints']['end'] = self._io.pos()
+
+    class Utf8Codepoint(KaitaiStruct):
+        SEQ_FIELDS = ["bytes"]
+        def __init__(self, ofs, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self.ofs = ofs
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['bytes']['start'] = self._io.pos()
+            self.bytes = self._io.read_bytes(self.len_bytes)
+            self._debug['bytes']['end'] = self._io.pos()
+
+        @property
+        def raw1(self):
+            if hasattr(self, '_m_raw1'):
+                return self._m_raw1 if hasattr(self, '_m_raw1') else None
+
+            if self.len_bytes >= 2:
+                self._m_raw1 = (KaitaiStream.byte_array_index(self.bytes, 1) & 63)
+
+            return self._m_raw1 if hasattr(self, '_m_raw1') else None
+
+        @property
+        def len_bytes(self):
+            if hasattr(self, '_m_len_bytes'):
+                return self._m_len_bytes if hasattr(self, '_m_len_bytes') else None
+
+            self._m_len_bytes = (1 if (self.byte0 & 128) == 0 else (2 if (self.byte0 & 224) == 192 else (3 if (self.byte0 & 240) == 224 else (4 if (self.byte0 & 248) == 240 else -1))))
+            return self._m_len_bytes if hasattr(self, '_m_len_bytes') else None
+
+        @property
+        def raw3(self):
+            if hasattr(self, '_m_raw3'):
+                return self._m_raw3 if hasattr(self, '_m_raw3') else None
+
+            if self.len_bytes >= 4:
+                self._m_raw3 = (KaitaiStream.byte_array_index(self.bytes, 3) & 63)
+
+            return self._m_raw3 if hasattr(self, '_m_raw3') else None
+
+        @property
+        def value_as_int(self):
+            if hasattr(self, '_m_value_as_int'):
+                return self._m_value_as_int if hasattr(self, '_m_value_as_int') else None
+
+            self._m_value_as_int = (self.raw0 if self.len_bytes == 1 else (((self.raw0 << 6) | self.raw1) if self.len_bytes == 2 else ((((self.raw0 << 12) | (self.raw1 << 6)) | self.raw2) if self.len_bytes == 3 else (((((self.raw0 << 18) | (self.raw1 << 12)) | (self.raw2 << 6)) | self.raw3) if self.len_bytes == 4 else -1))))
+            return self._m_value_as_int if hasattr(self, '_m_value_as_int') else None
+
+        @property
+        def raw0(self):
+            if hasattr(self, '_m_raw0'):
+                return self._m_raw0 if hasattr(self, '_m_raw0') else None
+
+            self._m_raw0 = (KaitaiStream.byte_array_index(self.bytes, 0) & (127 if self.len_bytes == 1 else (31 if self.len_bytes == 2 else (15 if self.len_bytes == 3 else (7 if self.len_bytes == 4 else 0)))))
+            return self._m_raw0 if hasattr(self, '_m_raw0') else None
+
+        @property
+        def byte0(self):
+            if hasattr(self, '_m_byte0'):
+                return self._m_byte0 if hasattr(self, '_m_byte0') else None
+
+            _pos = self._io.pos()
+            self._io.seek(self.ofs)
+            self._debug['_m_byte0']['start'] = self._io.pos()
+            self._m_byte0 = self._io.read_u1()
+            self._debug['_m_byte0']['end'] = self._io.pos()
+            self._io.seek(_pos)
+            return self._m_byte0 if hasattr(self, '_m_byte0') else None
+
+        @property
+        def raw2(self):
+            if hasattr(self, '_m_raw2'):
+                return self._m_raw2 if hasattr(self, '_m_raw2') else None
+
+            if self.len_bytes >= 3:
+                self._m_raw2 = (KaitaiStream.byte_array_index(self.bytes, 2) & 63)
+
+            return self._m_raw2 if hasattr(self, '_m_raw2') else None
+
+
+