diff --git a/README.md b/README.md index 76aae8e..4850822 100644 --- a/README.md +++ b/README.md @@ -2,8 +2,9 @@ A Dissect module implementing parsers for various database formats, including: -- Berkeley DB -- SQLite3 +- Berkeley DB, used for example in older RPM databases +- Microsofts Extensible Storage Engine (ESE), used for example in Active Directory, Exchange and Windows Update +- SQLite3, commonly used by applications to store configuration data For more information, please see [the documentation](https://docs.dissect.tools/en/latest/projects/dissect.database/index.html). @@ -17,6 +18,20 @@ pip install dissect.database This module is also automatically installed if you install the `dissect` package. +## Tools + +### Impacket compatibility shim for secretsdump.py + +Impacket does not ([yet](https://github.com/fortra/impacket/pull/1452)) have native support for `dissect.database`, +so in the meantime a compatibility shim is provided. To use this shim, simply install `dissect.database` using the +instructions above, and execute `secretsdump.py` like so: + +```bash +python -m dissect.database.ese.tools.impacket /path/to/impacket/examples/secretsdump.py -h +``` + +Impacket `secretsdump.py` will now use `dissect.database` for parsing the `NTDS.dit` file, resulting in a significant performance improvement! + ## Build and test instructions This project uses `tox` to build source and wheel distributions. Run the following command from the root folder to build diff --git a/dissect/database/__init__.py b/dissect/database/__init__.py index abf9d3d..a97bc2f 100644 --- a/dissect/database/__init__.py +++ b/dissect/database/__init__.py @@ -1,11 +1,13 @@ from __future__ import annotations from dissect.database.bsd.db import DB +from dissect.database.ese.ese import ESE from dissect.database.exception import Error from dissect.database.sqlite3.sqlite3 import SQLite3 __all__ = [ "DB", + "ESE", "Error", "SQLite3", ] diff --git a/dissect/database/ese/__init__.py b/dissect/database/ese/__init__.py new file mode 100644 index 0000000..6fcf956 --- /dev/null +++ b/dissect/database/ese/__init__.py @@ -0,0 +1,24 @@ +from __future__ import annotations + +from dissect.database.ese.ese import ESE +from dissect.database.ese.exception import ( + InvalidDatabase, + KeyNotFoundError, + NoNeighbourPageError, +) +from dissect.database.ese.index import Index +from dissect.database.ese.page import Page +from dissect.database.ese.record import Record +from dissect.database.ese.table import Table + +__all__ = [ + "ESE", + "CompressedTaggedDataError", + "Index", + "InvalidDatabase", + "KeyNotFoundError", + "NoNeighbourPageError", + "Page", + "Record", + "Table", +] diff --git a/dissect/database/ese/btree.py b/dissect/database/ese/btree.py new file mode 100644 index 0000000..6840453 --- /dev/null +++ b/dissect/database/ese/btree.py @@ -0,0 +1,166 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING + +from dissect.database.ese.exception import KeyNotFoundError, NoNeighbourPageError + +if TYPE_CHECKING: + from dissect.database.ese.ese import ESE + from dissect.database.ese.page import Node, Page + + +class BTree: + """A simple implementation for searching the ESE B+Trees. + + This is a stateful interactive class that moves an internal cursor to a position within the BTree. + + Args: + db: An instance of :class:`~dissect.database.ese.ese.ESE`. + page: The page to open the :class:`BTree` on. + """ + + def __init__(self, db: ESE, root: int | Page): + self.db = db + + if isinstance(root, int): + page_num = root + root = db.page(page_num) + else: + page_num = root.num + + self.root = root + + self._page = root + self._page_num = page_num + self._node_num = 0 + + def reset(self) -> None: + """Reset the internal state to the root of the BTree.""" + self._page = self.root + self._page_num = self._page.num + self._node_num = 0 + + def node(self) -> Node: + """Return the node the BTree is currently on. + + Returns: + A :class:`~dissect.database.ese.page.Node` object of the current node. + """ + return self._page.node(self._node_num) + + def next(self) -> Node: + """Move the BTree to the next node and return it. + + Can move the BTree to the next page as a side effect. + + Returns: + A :class:`~dissect.database.ese.page.Node` object of the next node. + """ + if self._node_num + 1 > self._page.node_count - 1: + self.next_page() + else: + self._node_num += 1 + + return self.node() + + def next_page(self) -> None: + """Move the BTree to the next page in the tree. + + Raises: + NoNeighbourPageError: If the current page has no next page. + """ + if self._page.next_page: + self._page = self.db.page(self._page.next_page) + self._node_num = 0 + else: + raise NoNeighbourPageError(f"{self._page} has no next page") + + def prev(self) -> Node: + """Move the BTree to the previous node and return it. + + Can move the BTree to the previous page as a side effect. + + Returns: + A :class:`~dissect.database.ese.page.Node` object of the previous node. + """ + if self._node_num - 1 < 0: + self.prev_page() + else: + self._node_num -= 1 + + return self.node() + + def prev_page(self) -> None: + """Move the BTree to the previous page in the tree. + + Raises: + NoNeighbourPageError: If the current page has no previous page. + """ + if self._page.previous_page: + self._page = self.db.page(self._page.previous_page) + self._node_num = self._page.node_count - 1 + else: + raise NoNeighbourPageError(f"{self._page} has no previous page") + + def search(self, key: bytes, exact: bool = True) -> Node: + """Search the tree for the given ``key``. + + Moves the BTree to the matching node, or on the last node that is less than the requested key. + + Args: + key: The key to search for. + exact: Whether to only return successfully on an exact match. + + Raises: + KeyNotFoundError: If an ``exact`` match was requested but not found. + """ + page = self._page + while True: + node = find_node(page, key) + + if page.is_branch: + page = self.db.page(node.child) + else: + self._page = page + self._page_num = page.num + self._node_num = node.num + break + + if exact and key != node.key: + raise KeyNotFoundError(f"Can't find key: {key}") + + return self.node() + + +def find_node(page: Page, key: bytes) -> Node: + """Search a page for a node matching ``key``. + + Args: + page: The page to search. + key: The key to search. + """ + first_node_idx = 0 + last_node_idx = page.node_count - 1 + + node = None + while first_node_idx < last_node_idx: + node_idx = (first_node_idx + last_node_idx) // 2 + node = page.node(node_idx) + + # It turns out that the way BTree keys are compared matches 1:1 with how Python compares bytes + # First compare data, then length + if key < node.key: + last_node_idx = node_idx + elif key == node.key: + if page.is_branch: + # If there's an exact match on a key on a branch page, the actual leaf nodes are in the next branch + # Page keys for branch pages appear to be non-inclusive upper bounds + node_idx = min(node_idx + 1, page.node_count - 1) + node = page.node(node_idx) + + return node + else: + first_node_idx = node_idx + 1 + + # We're at the last node + return page.node(first_node_idx) diff --git a/dissect/database/ese/c_ese.py b/dissect/database/ese/c_ese.py new file mode 100644 index 0000000..edd5857 --- /dev/null +++ b/dissect/database/ese/c_ese.py @@ -0,0 +1,471 @@ +from __future__ import annotations + +from dissect.cstruct import cstruct + +# https://github.com/microsoft/Extensible-Storage-Engine +ese_def = """ +#define MAX_COMPUTERNAME_LENGTH 15 + +typedef int64 DBTIME; +typedef ULONG OBJID; +typedef ULONG PGNO; +typedef ULONG JET_ENGINEFORMATVERSION; +typedef int64 XECHECKSUM; + +enum CODEPAGE { + UNICODE = 1200, + WESTERN = 1252, + ASCII = 20127 +}; + +enum COMPRESSION_SCHEME { + COMPRESS_NONE = 0x0, + COMPRESS_7BITASCII = 0x1, + COMPRESS_7BITUNICODE = 0x2, + COMPRESS_XPRESS = 0x3, + COMPRESS_SCRUB = 0x4, + COMPRESS_XPRESS9 = 0x5, + COMPRESS_XPRESS10 = 0x6, +}; + +enum JET_coltyp { + Nil = 0, + Bit = 1, + UnsignedByte = 2, + Short = 3, + Long = 4, + Currency = 5, + IEEESingle = 6, + IEEEDouble = 7, + DateTime = 8, + Binary = 9, + Text = 10, + LongBinary = 11, + LongText = 12, + SLV = 13, + UnsignedLong = 14, + LongLong = 15, + GUID = 16, + UnsignedShort = 17, + Max = 18, +}; + +enum SYSOBJ { + Nil = 0, + Table = 1, + Column = 2, + Index = 3, + LongValue = 4, + Callback = 5, +}; + +struct LOGTIME { + BYTE bSeconds; // 0 - 60 + BYTE bMinutes; // 0 - 60 + BYTE bHours; // 0 - 24 + BYTE bDay; // 1 - 31 + BYTE bMonth; // 0 - 11 + BYTE bYear; // current year - 1900 + + BYTE fTimeIsUTC:1; + BYTE bMillisecondsLow:7; + + BYTE fReserved:1; // fOSSnapshot + BYTE bMillisecondsHigh:3; + BYTE fUnused:4; +}; + +struct LGPOS { + USHORT ib; // must be the last so that lgpos can + USHORT isec; // index of disksec starting logsec + LONG lGeneration; // generation of logsec +}; + +struct SIGNATURE { + ULONG ulRandom; // a random number + LOGTIME logtimeCreate; // time db created, in logtime format + CHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 1]; // where db is created +}; + +enum BKINFOTYPE : DWORD { + backupNormal = 0x0, // normal should be 0 for backward compatibility + backupOSSnapshot, + backupSnapshot, + backupSurrogate, // should not be persisted in header, but persisted and used by log. +}; + +struct BKINFO { + LGPOS lgposMark; // id for this backup + LOGTIME logtimeMark; // timestamp of when le_lgposMark was logged + ULONG genLow; // backup set's min lgen + ULONG genHigh; // backup set's max lgen +}; + +struct DBFILEHDR { + ULONG ulChecksum; // checksum of the 4k page + ULONG ulMagic; // Magic number + ULONG ulVersion; // version of DAE the db created (see ulDAEVersion) + LONG attrib; // attributes of the db +// 16 bytes + + DBTIME dbtimeDirtied; // DBTime of this database +// 24 bytes + + SIGNATURE signDb; // (28 bytes) signature of the db (incl. creation time) +// 52 bytes + + ULONG dbstate; // consistent/inconsistent state +// 56 bytes + + LGPOS lgposConsistent; // null if in inconsistent state + LOGTIME logtimeConsistent; // null if in inconsistent state +// 72 bytes + + LOGTIME logtimeAttach; // Last attach time + LGPOS lgposAttach; +// 88 bytes + + LOGTIME logtimeDetach; // Last detach time + LGPOS lgposDetach; +// 104 bytes + + ULONG dbid; // current db attachment +// 108 bytes + + SIGNATURE signLog; // log signature +// 136 bytes + + BKINFO bkinfoFullPrev; // Last successful full backup +// 160 bytes + + BKINFO bkinfoIncPrev; // Last successful Incremental backup +// 184 bytes // Reset when bkinfoFullPrev is set + + BKINFO bkinfoFullCur; // current backup. Succeed if a +// 208 bytes // corresponding pat file generated + + union { + ULONG m_ulDbFlags; + BYTE m_rgbDbFlags[4]; + }; + + OBJID objidLast; // Object id used so far. + + // NT version information. This is needed to decide if an index need + // be recreated due to sort table changes. + + DWORD dwMajorVersion; // OS version info + DWORD dwMinorVersion; +// 224 bytes + + DWORD dwBuildNumber; + LONG lSPNumber; // use 31 bit only + + ULONG ulDaeUpdateMajor; // used to track incremental database format updates that + // are backward-compatible (see ulDAEUpdateMajorMax) + + ULONG cbPageSize; // database page size (0 = 4k pages) +// 240 bytes + + ULONG ulRepairCount; // number of times ErrREPAIRAttachForRepair has been called on this database + LOGTIME logtimeRepair; // the date of the last time that repair was run +// 252 bytes + + BYTE rgbReservedSignSLV[ 28 ]; // signSLV signature of associated SLV file (obsolete) +// 280 bytes + + DBTIME dbtimeLastScrub; // last dbtime the database was zeroed out +// 288 bytes + + LOGTIME logtimeScrub; // the date of the last time that the database was zeroed out +// 296 bytes + + LONG lGenMinRequired; // the minimum log generation required for replaying the logs. Typically the checkpoint generation +// 300 bytes + + LONG lGenMaxRequired; // the maximum log generation required for replaying the logs. This is known as the waypoint in BF. +// 304 bytes + + LONG cpgUpgrade55Format; // + LONG cpgUpgradeFreePages; // + LONG cpgUpgradeSpaceMapPages; // +// 316 bytes + + BKINFO bkinfoSnapshotCur; // Current snapshot. +// 340 bytes + + ULONG ulCreateVersion; // version of DAE that created db (debugging only) + ULONG ulCreateUpdate; +// 348 bytes + + LOGTIME logtimeGenMaxCreate; // creation time of the genMax log file +// 356 bytes + + BKINFOTYPE bkinfoTypeFullPrev; // Type of Last successful full backup + BKINFOTYPE bkinfoTypeIncPrev; // Type of Last successful Incremental backup + +// 364 bytes + ULONG ulRepairCountOld; // number of times ErrREPAIRAttachForRepair has been called on this database before the last defrag + + ULONG ulECCFixSuccess; // number of times a one bit error was fixed and resulted in a good page + LOGTIME logtimeECCFixSuccess; // the date of the last time that a one bit error was fixed and resulted in a good page + ULONG ulECCFixSuccessOld; // number of times a one bit error was fixed and resulted in a good page before last repair + + ULONG ulECCFixFail; // number of times a one bit error was fixed and resulted in a bad page + LOGTIME logtimeECCFixFail; // the date of the last time that a one bit error was fixed and resulted in a bad page + ULONG ulECCFixFailOld; // number of times a one bit error was fixed and resulted in a bad page before last repair + + ULONG ulBadChecksum; // number of times a non-correctable ECC/checksum error was found + LOGTIME logtimeBadChecksum; // the date of the last time that a non-correctable ECC/checksum error was found + ULONG ulBadChecksumOld; // number of times a non-correctable ECC/checksum error was found before last repair + +// 416 bytes + + LONG lGenMaxCommitted; // the last log generation to take active log records for this database. Not + // ensuring replay through this log generation will lose the D in ACID. +// 420 bytes + BKINFO bkinfoCopyPrev; // Last successful Copy backup + BKINFO bkinfoDiffPrev; // Last successful Differential backup, reset when bkinfoFullPrev is set + +// 468 bytes + BKINFOTYPE bkinfoTypeCopyPrev; // Type of Last successful Incremental backup + BKINFOTYPE bkinfoTypeDiffPrev; // Type of Last successful Differential backup + +// 476 bytes + ULONG ulIncrementalReseedCount; // number of times incremental reseed has been initiated on this database + LOGTIME logtimeIncrementalReseed; // the date of the last time that incremental reseed was initiated on this database + ULONG ulIncrementalReseedCountOld; // number of times incremental reseed was initiated on this database before the last defrag + + ULONG ulPagePatchCount; // number of pages patched in the database as a part of incremental reseed + LOGTIME logtimePagePatch; // the date of the last time that a page was patched as a part of incremental reseed + ULONG ulPagePatchCountOld; // number of pages patched in the database as a part of incremental reseed before the last defrag + +// 508 bytes + QWORD qwSortVersion; // DEPRECATED: In old versions had "default" (?English?) LCID version, in new versions has 0xFFFFFFFFFFFF. + +// 516 bytes // checksum during recovery state + LOGTIME logtimeDbscanPrev; // last checksum finish time (UTC - 1900y) + LOGTIME logtimeDbscanStart; // start time (UTC - 1900y) + PGNO pgnoDbscanHighestContinuous; // current pgno + +// 536 bytes + LONG lGenRecovering; // the current log generation that we are doing recovery::redo for. + +// 540 bytes + + ULONG ulExtendCount; + LOGTIME logtimeLastExtend; + ULONG ulShrinkCount; + LOGTIME logtimeLastShrink; + +// 564 bytes + + LOGTIME logtimeLastReAttach; + LGPOS lgposLastReAttach; +// 580 bytes + + ULONG ulTrimCount; +// 584 bytes + + SIGNATURE signDbHdrFlush; // random signature generated at the time of the last DB header flush + SIGNATURE signFlushMapHdrFlush; // random signature generated at the time of the last FM header flush +// 640 bytes + + LONG lGenMinConsistent; // the minimum log generation required to bring the database to a clean state + // it might be different from lGenMinRequired, which also encompasses flush map consistency +// 644 bytes + + ULONG ulDaeUpdateMinor; // used to track incremental database format updates that + // are forwards-compatible (see ulDAEUpdateMinorMax) + JET_ENGINEFORMATVERSION efvMaxBinAttachDiagnostic; // Max version of engine binary that has attached this database. + // NOTE: This is NOT necessarily the format the DB creates/should maintain if JET_paramEnableFormatVersion is set. + // NOTE: ALSO this is NOT propagated via redo, intentionally to avoid dependency on this. Use le_ulDaeUpdateMinor instead. +// 652 bytes + + PGNO pgnoDbscanHighest; // highest pgno - used to avoid re-scanning pages +// 656 bytes + + LGPOS lgposLastResize; // lgpos of the last database resize committed to the database. + // This is unset on older builds and it requires JET_efvLgposLastResize to start being populated. + // A database attachment sets this to le_lgposAttach, even though there isn't a real resize, so it can be + // be viewed as "resize checkpoint". + // A database extension or shrinkage updates this to the LGPOS of the operation. + // A clean databse detachment sets this to le_lgposConsistent. + // Incremental reseed may set this back if the first divergent log is lower than the current le_lgposLastResize. +// 664 bytes + + BYTE rgbReserved[3]; // keeping the le_filetype in the same + // place as log file header and checkpoint + // file header + // Remember: when updating logfile, checkpoint or + // flush map file headers, please check here +// 667 bytes + + // WARNING: MUST be placed at this offset for + // uniformity with db/log headers + ULONG filetype; // JET_filetypeDatabase or JET_filetypeStreamingFile +// 671 bytes + + BYTE rgbReserved2[1]; // For alignment +// 672 bytes + + LOGTIME logtimeGenMaxRequired; +// 680 bytes + + LONG lGenPreRedoMinConsistent; // the minimum log generation required to bring the database to a clean state (value overriden during the start of redo, 0 if not overriden). + LONG lGenPreRedoMinRequired; // the minimum log generation required for replaying the logs (value overriden during the start of redo, 0 if not overriden). +// 688 bytes + + SIGNATURE signRBSHdrFlush; // random signature generated at the time of the last RBS header flush +// 716 bytes + + ULONG ulRevertCount; // number of times revert has been initiated on this database using the revert snapshots. + LOGTIME logtimeRevertFrom; // the date of the last time that revert was initiated on this database using the revert snapshots. + LOGTIME logtimeRevertTo; // the date of the last time we were reverting this database to. + ULONG ulRevertPageCount; // number of pages reverted on the database by the recent revert operation. + LGPOS lgposCommitBeforeRevert; // lgpos of the last commit on the database before a revert was done and requires JET_efvApplyRevertSnapshot to start being populated. + // This will be set only after a revert is completed and will be used to ignore JET_errDbTimeTooOld on passive copies. + // This is because as part of revert any new page reverts will cause the page to be zeroed out and thereby might be behind the active's dbtime for the page. +}; + +flag PAGE_FLAG : uint32 { + // where we are in the BTree + Root = 0x00000001, // fPageRoot + Leaf = 0x00000002, // fPageLeaf + ParentOfLeaf = 0x00000004, // fPageParentOfLeaf + // special flags + Empty = 0x00000008, // fPageEmpty + Repair = 0x00000010, // fPageRepair + // what type of tree we are in + Primary = 0x00000000, // fPagePrimary + SpaceTree = 0x00000020, // fPageSpaceTree + Index = 0x00000040, // fPageIndex + LongValue = 0x00000080, // fPageLongValue + // type of BTree key validation + NonUniqueKeys = 0x00000400, // fPageNonUniqueKeys + // upgrade info + NewRecordFormat = 0x00000800, // fPageNewRecordFormat + NewChecksumFormat = 0x00002000, // fPageNewChecksumFormat + Scrubbed = 0x00004000, // fPageScrubbed +}; + +struct PGHDR { + XECHECKSUM checksum; + DBTIME dbtimeDirtied; + PGNO pgnoPrev; + PGNO pgnoNext; + OBJID objidFDP; + USHORT cbFree; + USHORT cbUncommittedFree; + USHORT ibMicFree; + USHORT itagState; + PAGE_FLAG fFlags; +}; + +struct PGHDR2 { + // PGHDR pghdr; + XECHECKSUM rgChecksum[3]; + PGNO pgno; + CHAR rgbReserved[12]; +}; + +flag TAG_FLAG : uint16 { + Version = 0x01, // fNDVersion + Deleted = 0x02, // fNDDeleted + Compressed = 0x04, // fNDCompressed +}; + +struct TAG { + USHORT cb_; // size + USHORT ib_; // offset +}; + +typedef WORD RECOFFSET; + +struct RECHDR { + BYTE fidFixedLastInRec; + BYTE fidVarLastInRec; + RECOFFSET ibEndOfFixedData; +}; + +flag TAGFLD_HEADER : uint8 { + Invalid = 0x00, // Not a real flag + LongValue = 0x01, // fLongValue, is the column type JET_coltypLongText or JET_coltypLongBinary + Compressed = 0x02, // fCompressed + Separated = 0x04, // fSeparated, is the data stored in a long value page + MultiValues = 0x08, // fMultiValues + TwoValues = 0x10, // fTwoValues + Null = 0x20, // fNull + Encrypted = 0x40, // fEncrypted +}; + +flag JET_bitIndex : uint32 { + Unique = 0x00000001, + Primary = 0x00000002, + DisallowNull = 0x00000004, + IgnoreNull = 0x00000008, + Clustered40 = 0x00000010, // for backward compatibility + IgnoreAnyNull = 0x00000020, + IgnoreFirstNull = 0x00000040, + LazyFlush = 0x00000080, + Empty = 0x00000100, // don't attempt to build index, because all entries would evaluate to NULL (MUST also specify JET_bitIgnoreAnyNull) + Unversioned = 0x00000200, + SortNullsHigh = 0x00000400, // NULL sorts after data for all columns in the index + Unicode = 0x00000800, + Tuples = 0x00001000, // index on substring tuples (text columns only) + TupleLimits = 0x00002000, // cbVarSegMac field of JET_INDEXCREATE actually points to a JET_TUPLELIMITS struct to allow custom tuple index limits (implies JET_bitIndexTuples) + CrossProduct = 0x00004000, // index over multiple multi-valued columns has full cross product + KeyMost = 0x00008000, // custom index key size set instead of default of 255 bytes + DisallowTruncation = 0x00010000, // fail update rather than truncate index keys + NestedTable = 0x00020000, // index over multiple multi-valued columns but only with values of same itagSequence + DotNetGuid = 0x00040000, // index over GUID column according to .Net GUID sort order + ImmutableStructure = 0x00080000, // Do not write to the input structures during a JetCreateIndexN call. +}; + +flag IDBFLAG : uint16 { + Unique = 0x0001, // Duplicate keys not allowed + AllowAllNulls = 0x0002, // Make entries for NULL keys (all segments are null) + AllowFirstNull = 0x0004, // First index column NULL allowed in index + AllowSomeNulls = 0x0008, // Make entries for keys with some null segments + NoNullSeg = 0x0010, // Don't allow a NULL key segment + Primary = 0x0020, // Index is the primary index + LocaleSet = 0x0040, // Index locale information (locale name) is set (JET_bitIndexUnicode was specified). + Multivalued = 0x0080, // Has a multivalued segment + TemplateIndex = 0x0100, // Index of a template table + DerivedIndex = 0x0200, // Index derived from template table + // Note that this flag is persisted, but + // never used in an in-memory IDB, because + // we use the template index IDB instead. + LocalizedText = 0x0400, // Has a unicode text column? (code page is 1200) + SortNullsHigh = 0x0800, // NULL sorts after data + // Jan 2012: MSU is being removed. fidbUnicodeFixupOn should no longer be referenced. + UnicodeFixupOn_Deprecated = 0x1000, // Track entries with undefined Unicode codepoints + CrossProduct = 0x2000, // all combinations of multi-valued columns are indexed + DisallowTruncation = 0x4000, // fail update rather than allow key truncation + NestedTable = 0x8000, // combinations of multi-valued columns of same itagSequence are indexed +}; + +flag IDXFLAG : uint16 { + ExtendedColumns = 0x0001, // IDXSEGs are comprised of JET_COLUMNIDs, not FIDs + DotNetGuid = 0x0002, // GUIDs sort according to .Net rules +}; +""" # noqa E501 + +c_ese = cstruct().load(ese_def) + +ulDAEMagic = 0x89ABCDEF +pgnoFDPMSO = 4 +pgnoFDPMSO_NameIndex = 7 +pgnoFDPMSO_RootObjectIndex = 10 +pgnoFDPMSOShadow = 24 + +JET_coltyp = c_ese.JET_coltyp +JET_bitIndex = c_ese.JET_bitIndex +SYSOBJ = c_ese.SYSOBJ +PAGE_FLAG = c_ese.PAGE_FLAG +TAG_FLAG = c_ese.TAG_FLAG +TAGFLD_HEADER = c_ese.TAGFLD_HEADER +CODEPAGE = c_ese.CODEPAGE +COMPRESSION_SCHEME = c_ese.COMPRESSION_SCHEME +IDBFLAG = c_ese.IDBFLAG +IDXFLAG = c_ese.IDXFLAG diff --git a/dissect/database/ese/c_ese.pyi b/dissect/database/ese/c_ese.pyi new file mode 100644 index 0000000..abc1fbe --- /dev/null +++ b/dissect/database/ese/c_ese.pyi @@ -0,0 +1,491 @@ +# Generated by cstruct-stubgen +from typing import BinaryIO, Literal, TypeAlias, overload + +import dissect.cstruct as __cs__ + +class _c_ese(__cs__.cstruct): + MAX_COMPUTERNAME_LENGTH: Literal[15] = ... + DBTIME: TypeAlias = _c_ese.int64 + OBJID: TypeAlias = _c_ese.uint32 + PGNO: TypeAlias = _c_ese.uint32 + JET_ENGINEFORMATVERSION: TypeAlias = _c_ese.uint32 + XECHECKSUM: TypeAlias = _c_ese.int64 + class CODEPAGE(__cs__.Enum): + UNICODE = ... + WESTERN = ... + ASCII = ... + + class COMPRESSION_SCHEME(__cs__.Enum): + COMPRESS_NONE = ... + COMPRESS_7BITASCII = ... + COMPRESS_7BITUNICODE = ... + COMPRESS_XPRESS = ... + COMPRESS_SCRUB = ... + COMPRESS_XPRESS9 = ... + COMPRESS_XPRESS10 = ... + + class JET_coltyp(__cs__.Enum): + Nil = ... + Bit = ... + UnsignedByte = ... + Short = ... + Long = ... + Currency = ... + IEEESingle = ... + IEEEDouble = ... + DateTime = ... + Binary = ... + Text = ... + LongBinary = ... + LongText = ... + SLV = ... + UnsignedLong = ... + LongLong = ... + GUID = ... + UnsignedShort = ... + Max = ... + + class SYSOBJ(__cs__.Enum): + Nil = ... + Table = ... + Column = ... + Index = ... + LongValue = ... + Callback = ... + + class LOGTIME(__cs__.Structure): + bSeconds: _c_ese.uint8 + bMinutes: _c_ese.uint8 + bHours: _c_ese.uint8 + bDay: _c_ese.uint8 + bMonth: _c_ese.uint8 + bYear: _c_ese.uint8 + fTimeIsUTC: _c_ese.uint8 + bMillisecondsLow: _c_ese.uint8 + fReserved: _c_ese.uint8 + bMillisecondsHigh: _c_ese.uint8 + fUnused: _c_ese.uint8 + @overload + def __init__( + self, + bSeconds: _c_ese.uint8 | None = ..., + bMinutes: _c_ese.uint8 | None = ..., + bHours: _c_ese.uint8 | None = ..., + bDay: _c_ese.uint8 | None = ..., + bMonth: _c_ese.uint8 | None = ..., + bYear: _c_ese.uint8 | None = ..., + fTimeIsUTC: _c_ese.uint8 | None = ..., + bMillisecondsLow: _c_ese.uint8 | None = ..., + fReserved: _c_ese.uint8 | None = ..., + bMillisecondsHigh: _c_ese.uint8 | None = ..., + fUnused: _c_ese.uint8 | None = ..., + ): ... + @overload + def __init__(self, fh: bytes | memoryview | bytearray | BinaryIO, /): ... + + class LGPOS(__cs__.Structure): + ib: _c_ese.uint16 + isec: _c_ese.uint16 + lGeneration: _c_ese.int32 + @overload + def __init__( + self, + ib: _c_ese.uint16 | None = ..., + isec: _c_ese.uint16 | None = ..., + lGeneration: _c_ese.int32 | None = ..., + ): ... + @overload + def __init__(self, fh: bytes | memoryview | bytearray | BinaryIO, /): ... + + class SIGNATURE(__cs__.Structure): + ulRandom: _c_ese.uint32 + logtimeCreate: _c_ese.LOGTIME + szComputerName: __cs__.CharArray + @overload + def __init__( + self, + ulRandom: _c_ese.uint32 | None = ..., + logtimeCreate: _c_ese.LOGTIME | None = ..., + szComputerName: __cs__.CharArray | None = ..., + ): ... + @overload + def __init__(self, fh: bytes | memoryview | bytearray | BinaryIO, /): ... + + class BKINFOTYPE(__cs__.Enum): + backupNormal = ... + backupOSSnapshot = ... + backupSnapshot = ... + backupSurrogate = ... + + class BKINFO(__cs__.Structure): + lgposMark: _c_ese.LGPOS + logtimeMark: _c_ese.LOGTIME + genLow: _c_ese.uint32 + genHigh: _c_ese.uint32 + @overload + def __init__( + self, + lgposMark: _c_ese.LGPOS | None = ..., + logtimeMark: _c_ese.LOGTIME | None = ..., + genLow: _c_ese.uint32 | None = ..., + genHigh: _c_ese.uint32 | None = ..., + ): ... + @overload + def __init__(self, fh: bytes | memoryview | bytearray | BinaryIO, /): ... + + class DBFILEHDR(__cs__.Structure): + ulChecksum: _c_ese.uint32 + ulMagic: _c_ese.uint32 + ulVersion: _c_ese.uint32 + attrib: _c_ese.int32 + dbtimeDirtied: _c_ese.int64 + signDb: _c_ese.SIGNATURE + dbstate: _c_ese.uint32 + lgposConsistent: _c_ese.LGPOS + logtimeConsistent: _c_ese.LOGTIME + logtimeAttach: _c_ese.LOGTIME + lgposAttach: _c_ese.LGPOS + logtimeDetach: _c_ese.LOGTIME + lgposDetach: _c_ese.LGPOS + dbid: _c_ese.uint32 + signLog: _c_ese.SIGNATURE + bkinfoFullPrev: _c_ese.BKINFO + bkinfoIncPrev: _c_ese.BKINFO + bkinfoFullCur: _c_ese.BKINFO + m_ulDbFlags: _c_ese.uint32 + m_rgbDbFlags: __cs__.Array[_c_ese.uint8] + objidLast: _c_ese.uint32 + dwMajorVersion: _c_ese.uint32 + dwMinorVersion: _c_ese.uint32 + dwBuildNumber: _c_ese.uint32 + lSPNumber: _c_ese.int32 + ulDaeUpdateMajor: _c_ese.uint32 + cbPageSize: _c_ese.uint32 + ulRepairCount: _c_ese.uint32 + logtimeRepair: _c_ese.LOGTIME + rgbReservedSignSLV: __cs__.Array[_c_ese.uint8] + dbtimeLastScrub: _c_ese.int64 + logtimeScrub: _c_ese.LOGTIME + lGenMinRequired: _c_ese.int32 + lGenMaxRequired: _c_ese.int32 + cpgUpgrade55Format: _c_ese.int32 + cpgUpgradeFreePages: _c_ese.int32 + cpgUpgradeSpaceMapPages: _c_ese.int32 + bkinfoSnapshotCur: _c_ese.BKINFO + ulCreateVersion: _c_ese.uint32 + ulCreateUpdate: _c_ese.uint32 + logtimeGenMaxCreate: _c_ese.LOGTIME + bkinfoTypeFullPrev: _c_ese.BKINFOTYPE + bkinfoTypeIncPrev: _c_ese.BKINFOTYPE + ulRepairCountOld: _c_ese.uint32 + ulECCFixSuccess: _c_ese.uint32 + logtimeECCFixSuccess: _c_ese.LOGTIME + ulECCFixSuccessOld: _c_ese.uint32 + ulECCFixFail: _c_ese.uint32 + logtimeECCFixFail: _c_ese.LOGTIME + ulECCFixFailOld: _c_ese.uint32 + ulBadChecksum: _c_ese.uint32 + logtimeBadChecksum: _c_ese.LOGTIME + ulBadChecksumOld: _c_ese.uint32 + lGenMaxCommitted: _c_ese.int32 + bkinfoCopyPrev: _c_ese.BKINFO + bkinfoDiffPrev: _c_ese.BKINFO + bkinfoTypeCopyPrev: _c_ese.BKINFOTYPE + bkinfoTypeDiffPrev: _c_ese.BKINFOTYPE + ulIncrementalReseedCount: _c_ese.uint32 + logtimeIncrementalReseed: _c_ese.LOGTIME + ulIncrementalReseedCountOld: _c_ese.uint32 + ulPagePatchCount: _c_ese.uint32 + logtimePagePatch: _c_ese.LOGTIME + ulPagePatchCountOld: _c_ese.uint32 + qwSortVersion: _c_ese.uint64 + logtimeDbscanPrev: _c_ese.LOGTIME + logtimeDbscanStart: _c_ese.LOGTIME + pgnoDbscanHighestContinuous: _c_ese.uint32 + lGenRecovering: _c_ese.int32 + ulExtendCount: _c_ese.uint32 + logtimeLastExtend: _c_ese.LOGTIME + ulShrinkCount: _c_ese.uint32 + logtimeLastShrink: _c_ese.LOGTIME + logtimeLastReAttach: _c_ese.LOGTIME + lgposLastReAttach: _c_ese.LGPOS + ulTrimCount: _c_ese.uint32 + signDbHdrFlush: _c_ese.SIGNATURE + signFlushMapHdrFlush: _c_ese.SIGNATURE + lGenMinConsistent: _c_ese.int32 + ulDaeUpdateMinor: _c_ese.uint32 + efvMaxBinAttachDiagnostic: _c_ese.uint32 + pgnoDbscanHighest: _c_ese.uint32 + lgposLastResize: _c_ese.LGPOS + rgbReserved: __cs__.Array[_c_ese.uint8] + filetype: _c_ese.uint32 + rgbReserved2: __cs__.Array[_c_ese.uint8] + logtimeGenMaxRequired: _c_ese.LOGTIME + lGenPreRedoMinConsistent: _c_ese.int32 + lGenPreRedoMinRequired: _c_ese.int32 + signRBSHdrFlush: _c_ese.SIGNATURE + ulRevertCount: _c_ese.uint32 + logtimeRevertFrom: _c_ese.LOGTIME + logtimeRevertTo: _c_ese.LOGTIME + ulRevertPageCount: _c_ese.uint32 + lgposCommitBeforeRevert: _c_ese.LGPOS + @overload + def __init__( + self, + ulChecksum: _c_ese.uint32 | None = ..., + ulMagic: _c_ese.uint32 | None = ..., + ulVersion: _c_ese.uint32 | None = ..., + attrib: _c_ese.int32 | None = ..., + dbtimeDirtied: _c_ese.int64 | None = ..., + signDb: _c_ese.SIGNATURE | None = ..., + dbstate: _c_ese.uint32 | None = ..., + lgposConsistent: _c_ese.LGPOS | None = ..., + logtimeConsistent: _c_ese.LOGTIME | None = ..., + logtimeAttach: _c_ese.LOGTIME | None = ..., + lgposAttach: _c_ese.LGPOS | None = ..., + logtimeDetach: _c_ese.LOGTIME | None = ..., + lgposDetach: _c_ese.LGPOS | None = ..., + dbid: _c_ese.uint32 | None = ..., + signLog: _c_ese.SIGNATURE | None = ..., + bkinfoFullPrev: _c_ese.BKINFO | None = ..., + bkinfoIncPrev: _c_ese.BKINFO | None = ..., + bkinfoFullCur: _c_ese.BKINFO | None = ..., + m_ulDbFlags: _c_ese.uint32 | None = ..., + m_rgbDbFlags: __cs__.Array[_c_ese.uint8] | None = ..., + objidLast: _c_ese.uint32 | None = ..., + dwMajorVersion: _c_ese.uint32 | None = ..., + dwMinorVersion: _c_ese.uint32 | None = ..., + dwBuildNumber: _c_ese.uint32 | None = ..., + lSPNumber: _c_ese.int32 | None = ..., + ulDaeUpdateMajor: _c_ese.uint32 | None = ..., + cbPageSize: _c_ese.uint32 | None = ..., + ulRepairCount: _c_ese.uint32 | None = ..., + logtimeRepair: _c_ese.LOGTIME | None = ..., + rgbReservedSignSLV: __cs__.Array[_c_ese.uint8] | None = ..., + dbtimeLastScrub: _c_ese.int64 | None = ..., + logtimeScrub: _c_ese.LOGTIME | None = ..., + lGenMinRequired: _c_ese.int32 | None = ..., + lGenMaxRequired: _c_ese.int32 | None = ..., + cpgUpgrade55Format: _c_ese.int32 | None = ..., + cpgUpgradeFreePages: _c_ese.int32 | None = ..., + cpgUpgradeSpaceMapPages: _c_ese.int32 | None = ..., + bkinfoSnapshotCur: _c_ese.BKINFO | None = ..., + ulCreateVersion: _c_ese.uint32 | None = ..., + ulCreateUpdate: _c_ese.uint32 | None = ..., + logtimeGenMaxCreate: _c_ese.LOGTIME | None = ..., + bkinfoTypeFullPrev: _c_ese.BKINFOTYPE | None = ..., + bkinfoTypeIncPrev: _c_ese.BKINFOTYPE | None = ..., + ulRepairCountOld: _c_ese.uint32 | None = ..., + ulECCFixSuccess: _c_ese.uint32 | None = ..., + logtimeECCFixSuccess: _c_ese.LOGTIME | None = ..., + ulECCFixSuccessOld: _c_ese.uint32 | None = ..., + ulECCFixFail: _c_ese.uint32 | None = ..., + logtimeECCFixFail: _c_ese.LOGTIME | None = ..., + ulECCFixFailOld: _c_ese.uint32 | None = ..., + ulBadChecksum: _c_ese.uint32 | None = ..., + logtimeBadChecksum: _c_ese.LOGTIME | None = ..., + ulBadChecksumOld: _c_ese.uint32 | None = ..., + lGenMaxCommitted: _c_ese.int32 | None = ..., + bkinfoCopyPrev: _c_ese.BKINFO | None = ..., + bkinfoDiffPrev: _c_ese.BKINFO | None = ..., + bkinfoTypeCopyPrev: _c_ese.BKINFOTYPE | None = ..., + bkinfoTypeDiffPrev: _c_ese.BKINFOTYPE | None = ..., + ulIncrementalReseedCount: _c_ese.uint32 | None = ..., + logtimeIncrementalReseed: _c_ese.LOGTIME | None = ..., + ulIncrementalReseedCountOld: _c_ese.uint32 | None = ..., + ulPagePatchCount: _c_ese.uint32 | None = ..., + logtimePagePatch: _c_ese.LOGTIME | None = ..., + ulPagePatchCountOld: _c_ese.uint32 | None = ..., + qwSortVersion: _c_ese.uint64 | None = ..., + logtimeDbscanPrev: _c_ese.LOGTIME | None = ..., + logtimeDbscanStart: _c_ese.LOGTIME | None = ..., + pgnoDbscanHighestContinuous: _c_ese.uint32 | None = ..., + lGenRecovering: _c_ese.int32 | None = ..., + ulExtendCount: _c_ese.uint32 | None = ..., + logtimeLastExtend: _c_ese.LOGTIME | None = ..., + ulShrinkCount: _c_ese.uint32 | None = ..., + logtimeLastShrink: _c_ese.LOGTIME | None = ..., + logtimeLastReAttach: _c_ese.LOGTIME | None = ..., + lgposLastReAttach: _c_ese.LGPOS | None = ..., + ulTrimCount: _c_ese.uint32 | None = ..., + signDbHdrFlush: _c_ese.SIGNATURE | None = ..., + signFlushMapHdrFlush: _c_ese.SIGNATURE | None = ..., + lGenMinConsistent: _c_ese.int32 | None = ..., + ulDaeUpdateMinor: _c_ese.uint32 | None = ..., + efvMaxBinAttachDiagnostic: _c_ese.uint32 | None = ..., + pgnoDbscanHighest: _c_ese.uint32 | None = ..., + lgposLastResize: _c_ese.LGPOS | None = ..., + rgbReserved: __cs__.Array[_c_ese.uint8] | None = ..., + filetype: _c_ese.uint32 | None = ..., + rgbReserved2: __cs__.Array[_c_ese.uint8] | None = ..., + logtimeGenMaxRequired: _c_ese.LOGTIME | None = ..., + lGenPreRedoMinConsistent: _c_ese.int32 | None = ..., + lGenPreRedoMinRequired: _c_ese.int32 | None = ..., + signRBSHdrFlush: _c_ese.SIGNATURE | None = ..., + ulRevertCount: _c_ese.uint32 | None = ..., + logtimeRevertFrom: _c_ese.LOGTIME | None = ..., + logtimeRevertTo: _c_ese.LOGTIME | None = ..., + ulRevertPageCount: _c_ese.uint32 | None = ..., + lgposCommitBeforeRevert: _c_ese.LGPOS | None = ..., + ): ... + @overload + def __init__(self, fh: bytes | memoryview | bytearray | BinaryIO, /): ... + + class PAGE_FLAG(__cs__.Flag): + Root = ... + Leaf = ... + ParentOfLeaf = ... + Empty = ... + Repair = ... + Primary = ... + SpaceTree = ... + Index = ... + LongValue = ... + NonUniqueKeys = ... + NewRecordFormat = ... + NewChecksumFormat = ... + Scrubbed = ... + + class PGHDR(__cs__.Structure): + checksum: _c_ese.int64 + dbtimeDirtied: _c_ese.int64 + pgnoPrev: _c_ese.uint32 + pgnoNext: _c_ese.uint32 + objidFDP: _c_ese.uint32 + cbFree: _c_ese.uint16 + cbUncommittedFree: _c_ese.uint16 + ibMicFree: _c_ese.uint16 + itagState: _c_ese.uint16 + fFlags: _c_ese.PAGE_FLAG + @overload + def __init__( + self, + checksum: _c_ese.int64 | None = ..., + dbtimeDirtied: _c_ese.int64 | None = ..., + pgnoPrev: _c_ese.uint32 | None = ..., + pgnoNext: _c_ese.uint32 | None = ..., + objidFDP: _c_ese.uint32 | None = ..., + cbFree: _c_ese.uint16 | None = ..., + cbUncommittedFree: _c_ese.uint16 | None = ..., + ibMicFree: _c_ese.uint16 | None = ..., + itagState: _c_ese.uint16 | None = ..., + fFlags: _c_ese.PAGE_FLAG | None = ..., + ): ... + @overload + def __init__(self, fh: bytes | memoryview | bytearray | BinaryIO, /): ... + + class PGHDR2(__cs__.Structure): + rgChecksum: __cs__.Array[_c_ese.int64] + pgno: _c_ese.uint32 + rgbReserved: __cs__.CharArray + @overload + def __init__( + self, + rgChecksum: __cs__.Array[_c_ese.int64] | None = ..., + pgno: _c_ese.uint32 | None = ..., + rgbReserved: __cs__.CharArray | None = ..., + ): ... + @overload + def __init__(self, fh: bytes | memoryview | bytearray | BinaryIO, /): ... + + class TAG_FLAG(__cs__.Flag): + Version = ... + Deleted = ... + Compressed = ... + + class TAG(__cs__.Structure): + cb_: _c_ese.uint16 + ib_: _c_ese.uint16 + @overload + def __init__(self, cb_: _c_ese.uint16 | None = ..., ib_: _c_ese.uint16 | None = ...): ... + @overload + def __init__(self, fh: bytes | memoryview | bytearray | BinaryIO, /): ... + + RECOFFSET: TypeAlias = _c_ese.uint16 + class RECHDR(__cs__.Structure): + fidFixedLastInRec: _c_ese.uint8 + fidVarLastInRec: _c_ese.uint8 + ibEndOfFixedData: _c_ese.uint16 + @overload + def __init__( + self, + fidFixedLastInRec: _c_ese.uint8 | None = ..., + fidVarLastInRec: _c_ese.uint8 | None = ..., + ibEndOfFixedData: _c_ese.uint16 | None = ..., + ): ... + @overload + def __init__(self, fh: bytes | memoryview | bytearray | BinaryIO, /): ... + + class TAGFLD_HEADER(__cs__.Flag): + Invalid = ... + LongValue = ... + Compressed = ... + Separated = ... + MultiValues = ... + TwoValues = ... + Null = ... + Encrypted = ... + + class JET_bitIndex(__cs__.Flag): + Unique = ... + Primary = ... + DisallowNull = ... + IgnoreNull = ... + Clustered40 = ... + IgnoreAnyNull = ... + IgnoreFirstNull = ... + LazyFlush = ... + Empty = ... + Unversioned = ... + SortNullsHigh = ... + Unicode = ... + Tuples = ... + TupleLimits = ... + CrossProduct = ... + KeyMost = ... + DisallowTruncation = ... + NestedTable = ... + DotNetGuid = ... + ImmutableStructure = ... + + class IDBFLAG(__cs__.Flag): + Unique = ... + AllowAllNulls = ... + AllowFirstNull = ... + AllowSomeNulls = ... + NoNullSeg = ... + Primary = ... + LocaleSet = ... + Multivalued = ... + TemplateIndex = ... + DerivedIndex = ... + LocalizedText = ... + SortNullsHigh = ... + UnicodeFixupOn_Deprecated = ... + CrossProduct = ... + DisallowTruncation = ... + NestedTable = ... + + class IDXFLAG(__cs__.Flag): + ExtendedColumns = ... + DotNetGuid = ... + +# Technically `c_ese` is an instance of `_c_ese`, but then we can't use it in type hints +c_ese: TypeAlias = _c_ese + +ulDAEMagic: int +pgnoFDPMSO: int +pgnoFDPMSO_NameIndex: int +pgnoFDPMSO_RootObjectIndex: int +pgnoFDPMSOShadow: int + +JET_coltyp: TypeAlias = c_ese.JET_coltyp +JET_bitIndex: TypeAlias = c_ese.JET_bitIndex +SYSOBJ: TypeAlias = c_ese.SYSOBJ +PAGE_FLAG: TypeAlias = c_ese.PAGE_FLAG +TAG_FLAG: TypeAlias = c_ese.TAG_FLAG +TAGFLD_HEADER: TypeAlias = c_ese.TAGFLD_HEADER +CODEPAGE: TypeAlias = c_ese.CODEPAGE +COMPRESSION_SCHEME: TypeAlias = c_ese.COMPRESSION_SCHEME +IDBFLAG: TypeAlias = c_ese.IDBFLAG +IDXFLAG: TypeAlias = c_ese.IDXFLAG diff --git a/dissect/database/ese/compression.py b/dissect/database/ese/compression.py new file mode 100644 index 0000000..92bf9da --- /dev/null +++ b/dissect/database/ese/compression.py @@ -0,0 +1,50 @@ +from __future__ import annotations + +import struct + +from dissect.util.compression import lzxpress, sevenbit + +from dissect.database.ese.c_ese import COMPRESSION_SCHEME + + +def decompress(buf: bytes) -> bytes: + """Decompress the given bytes according to the encoded compression scheme. + + Args: + buf: The compressed bytes to decompress. + + Raises: + NotImplementedError: If the buffer is compressed with an unsupported compression algorithm (XPRESS9/XPRESS10). + """ + identifier = buf[0] >> 3 + if identifier == COMPRESSION_SCHEME.COMPRESS_7BITASCII: + return sevenbit.decompress(buf[1:]) + if identifier == COMPRESSION_SCHEME.COMPRESS_7BITUNICODE: + return sevenbit.decompress(buf[1:], wide=True) + if identifier == COMPRESSION_SCHEME.COMPRESS_XPRESS: + return lzxpress.decompress(buf[3:]) + if identifier in (COMPRESSION_SCHEME.COMPRESS_XPRESS9, COMPRESSION_SCHEME.COMPRESS_XPRESS10): + raise NotImplementedError(f"Compression not yet implemented: {COMPRESSION_SCHEME(identifier)}") + # Not compressed + return buf + + +def decompress_size(buf: bytes) -> int | None: + """Return the decompressed size of the given bytes according to the encoded compression scheme. + + Args: + buf: The compressed bytes to return the decompressed size of. + + Raises: + NotImplementedError: If the buffer is compressed with an unsupported compression algorithm (XPRESS9/XPRESS10). + """ + identifier = buf[0] >> 3 + if identifier == COMPRESSION_SCHEME.COMPRESS_7BITASCII: + return ((buf[0] & 7) + (8 * len(buf))) // 7 + if identifier == COMPRESSION_SCHEME.COMPRESS_7BITUNICODE: + return 2 * (((buf[0] & 7) + (8 * len(buf))) // 7) + if identifier == COMPRESSION_SCHEME.COMPRESS_XPRESS: + return struct.unpack(" Iterator[Record]: + while True: + yield self._record() + + try: + self._primary.next() + except NoNeighbourPageError: + break + + def _node(self) -> Node: + """Return the node the cursor is currently on. Resolves the secondary index if needed. + + Returns: + A :class:`~dissect.database.ese.page.Node` object of the current node. + """ + node = self._primary.node() + if self._secondary: + self._secondary.reset() + node = self._secondary.search(node.data.tobytes(), exact=True) + return node + + def _record(self) -> Record: + """Return the record the cursor is currently on. + + Returns: + A :class:`~dissect.database.ese.record.Record` object of the current record. + """ + return Record(self.table, self._node()) + + def reset(self) -> None: + """Reset the internal state.""" + self._primary.reset() + if self._secondary: + self._secondary.reset() + + def search(self, **kwargs: RecordValue) -> Record: + """Search the index for the requested values. + + Searching modifies the cursor state. Searching again will search from the current position. + Reset the cursor with :meth:`reset` to start from the beginning. + + Args: + **kwargs: The columns and values to search for. + + Returns: + A :class:`~dissect.database.ese.record.Record` object of the found record. + """ + key = self.index.make_key(kwargs) + return self.search_key(key, exact=True) + + def search_key(self, key: bytes, exact: bool = True) -> Record: + """Search for a record with the given ``key``. + + Args: + key: The key to search for. + exact: If ``True``, search for an exact match. If ``False``, sets the cursor on the + next record that is greater than or equal to the key. + """ + self._primary.search(key, exact) + return self._record() + + def seek(self, **kwargs: RecordValue) -> None: + """Seek to the record with the given values. + + Args: + **kwargs: The columns and values to seek to. + """ + key = self.index.make_key(kwargs) + self.search_key(key, exact=False) + + def seek_key(self, key: bytes) -> None: + """Seek to the record with the given ``key``. + + Args: + key: The key to seek to. + """ + self._primary.search(key, exact=False) + + def find(self, **kwargs: RecordValue) -> Record | None: + """Find a record in the index. + + This differs from :meth:`search` in that it will allow additional filtering on non-indexed columns. + + Args: + **kwargs: The columns and values to search for. + """ + return next(self.find_all(**kwargs), None) + + def find_all(self, **kwargs: RecordValue) -> Iterator[Record]: + """Find all records in the index that match the given values. + + This differs from :meth:`search` in that it will allows additional filtering on non-indexed columns. + If you only search on indexed columns, this will yield all records that match the indexed columns. + + Args: + **kwargs: The columns and values to search for. + """ + indexed_columns = {c.name: kwargs.pop(c.name) for c in self.index.columns} + other_columns = kwargs + + # We need at least an exact match on the indexed columns + self.search(**indexed_columns) + + current_key = self._primary.node().key + + # Check if we need to move the cursor back to find the first record + while True: + if current_key != self._primary.node().key: + self._primary.next() + break + + try: + self._primary.prev() + except NoNeighbourPageError: + break + + while True: + # Entries with the same indexed columns are guaranteed to be adjacent + if current_key != self._primary.node().key: + break + + record = self._record() + for k, v in other_columns.items(): + value = record.get(k) + # If the record value is a list, we do a check based on the queried value + if isinstance(value, list): + # If the queried value is also a list, we check if they are equal + if isinstance(v, list): + if value != v: + break + # Otherwise we check if the queried value is in the record value + elif v not in value: + break + else: + if value != v: + break + else: + yield record + + try: + self._primary.next() + except NoNeighbourPageError: + break + + def record(self) -> Record: + """Return the record the cursor is currently on. + + Returns: + A :class:`~dissect.database.ese.record.Record` object of the current record. + """ + return self._record() + + def next(self) -> Record: + """Move the cursor to the next record and return it. + + Can move the cursor to the next page as a side effect. + + Returns: + A :class:`~dissect.database.ese.record.Record` object of the next record. + """ + try: + self._primary.next() + except NoNeighbourPageError: + raise IndexError("No next record") + return self._record() + + def prev(self) -> Record: + """Move the cursor to the previous node and return it. + + Can move the cursor to the previous page as a side effect. + + Returns: + A :class:`~dissect.database.ese.record.Record` object of the previous record. + """ + try: + self._primary.prev() + except NoNeighbourPageError: + raise IndexError("No previous record") + return self._record() diff --git a/dissect/database/ese/ese.py b/dissect/database/ese/ese.py new file mode 100755 index 0000000..b13cc6c --- /dev/null +++ b/dissect/database/ese/ese.py @@ -0,0 +1,108 @@ +# Extensible Storage Engine (ESE) Database implementation +# Combination of pre-source release reverse engineering and post-source release cleanup +# Reference: https://github.com/microsoft/Extensible-Storage-Engine +from __future__ import annotations + +import io +from functools import cached_property, lru_cache +from typing import TYPE_CHECKING, BinaryIO + +from dissect.database.ese.c_ese import c_ese, pgnoFDPMSO, ulDAEMagic +from dissect.database.ese.exception import InvalidDatabase +from dissect.database.ese.page import Page +from dissect.database.ese.table import Catalog, Table + +if TYPE_CHECKING: + from collections.abc import Iterator + + +class ESE: + """ESE database class. + + Loads an ESE database from the given file handle. Optionally enable impacket compatible data output. + + Impacket compatibility limits what values are parsed and returns most values as a hex string. Most notably, + long and multi values are not parsed. + + Args: + fh: The file-like object to open an ESE database on. + impacket_compat: Whether to make the output impacket compatible. + + Raises: + InvalidDatabase: If the file-like object does not look like an ESE database. + """ + + def __init__(self, fh: BinaryIO, impacket_compat: bool = False): + self.fh = fh + self.impacket_compat = impacket_compat + + self.header = c_ese.DBFILEHDR(fh) + if self.header.ulMagic != ulDAEMagic: + raise InvalidDatabase("invalid file header signature") + + self.page_size = self.header.cbPageSize + self.version = self.header.ulVersion + self.format_major = self.header.ulDaeUpdateMajor + self.format_minor = self.header.ulDaeUpdateMinor + + if self.format_major < 9: + raise InvalidDatabase("unsupported format revision") + + self.catalog = Catalog(self, pgnoFDPMSO) + + self.page = lru_cache(4096)(self.page) + + @cached_property + def has_small_pages(self) -> bool: + """Return whether this database has small pages (<= 8K).""" + return self.page_size <= 8192 + + def table(self, name: str) -> Table: + """Get a table by name. + + Args: + name: The table to retrieve. + """ + return self.catalog.table(name) + + def tables(self) -> list[Table]: + """Get a list of all tables.""" + return self.catalog.tables + + def read_page(self, num: int) -> bytes: + """Get the physical page data. + + Args: + num: The physical page number to retrieve. + + Raises: + IndexError: If the page number is out of bounds. + """ + if num < 1: + raise IndexError("page number cannot be less than 1") + + self.fh.seek((num - 1) * self.page_size) + buf = self.fh.read(self.page_size) + + if len(buf) != self.page_size: + raise IndexError("page number exceeds file size") + + return buf + + def page(self, num: int) -> Page: + """Get a logical page. + + The first two pages in the file are the Header and Shadow Header pages. + Logical pages start at physical page 2 (zero-indexed). + + Args: + num: The logical page number to retrieve. + """ + buf = self.read_page(num + 2) + return Page(self, num, buf) + + def pages(self) -> Iterator[Page]: + """Iterate over all pages.""" + size = self.fh.seek(0, io.SEEK_END) + for i in range(1, (size // self.page_size) - 1): + yield self.page(i) diff --git a/dissect/database/ese/exception.py b/dissect/database/ese/exception.py new file mode 100644 index 0000000..e736de2 --- /dev/null +++ b/dissect/database/ese/exception.py @@ -0,0 +1,15 @@ +from __future__ import annotations + +from dissect.database.exception import Error + + +class InvalidDatabase(Error): + pass + + +class KeyNotFoundError(Error): + pass + + +class NoNeighbourPageError(Error): + pass diff --git a/dissect/database/ese/index.py b/dissect/database/ese/index.py new file mode 100644 index 0000000..3523884 --- /dev/null +++ b/dissect/database/ese/index.py @@ -0,0 +1,297 @@ +from __future__ import annotations + +import struct +import uuid +from functools import cached_property +from typing import TYPE_CHECKING + +from dissect.database.ese.c_ese import CODEPAGE, IDBFLAG, IDXFLAG, JET_coltyp +from dissect.database.ese.cursor import Cursor +from dissect.database.ese.lcmapstring import map_string + +if TYPE_CHECKING: + from dissect.database.ese.page import Node, Page + from dissect.database.ese.record import Record + from dissect.database.ese.table import Column, Table + from dissect.database.ese.util import RecordValue + + +JET_cbKeyMost_OLD = 255 + + +class Index: + """Represents an index on a table. + + This is still very much WIP but works for basic indexes. + For example, none of the special flags are currently implemented. + + Args: + table: The table this index is from. + record: The record in the catalog for this index. + """ + + def __init__(self, table: Table, record: Record | None = None): + self.table = table + self.record = record + self.db = table.db + + self.name = record.get("Name") + flags = record.get("Flags") + self.idb_flags = IDBFLAG(flags & 0xFFFF) + self.idx_flags = IDXFLAG(flags >> 16) + self._key_most = record.get("KeyMost") or JET_cbKeyMost_OLD + self._var_seg_mac = record.get("VarSegMac") or self._key_most + + def __repr__(self) -> str: + return f"" + + @property + def is_primary(self) -> bool: + return bool(self.idb_flags & IDBFLAG.Primary) + + @cached_property + def root(self) -> Page: + """Return the root page of this index.""" + return self.db.page(self.record.get("ColtypOrPgnoFDP")) + + @cached_property + def column_ids(self) -> list[int]: + """Return a list of column IDs that are used in this index.""" + column_ids = [] + key_field_ids = self.record.get("KeyFldIDs") + if len(key_field_ids) % 4 == 0: + for i in range(0, len(key_field_ids), 4): + _, column_identifier = struct.unpack(" list[Column]: + """Return a list of all columns that are used in this index.""" + return [self.table._column_id_map[cid] for cid in self.column_ids] + + def cursor(self) -> Cursor: + """Create a new cursor for this index.""" + return Cursor(self) + + def search(self, **kwargs) -> Record: + """Search the index for the requested values. + + Args: + **kwargs: The columns and values to search for. + + Returns: + A :class:`~dissect.database.ese.record.Record` object of the found record. + """ + return self.cursor().search(**kwargs) + + def search_key(self, key: bytes) -> Node: + """Search the index for a specific ``key``. + + Args: + key: The key to search for. + + Returns: + A :class:`~dissect.database.ese.page.Node` object of the found node. + """ + return self.cursor().search_key(key) + + def key_from_record(self, record: Record) -> bytes: + """Generate a key for this index from a record. + + Args: + record: The record to generate a key for. + """ + values = {c.name: record[c.name] for c in self.columns} + return self.make_key(values) + + def make_key(self, values: dict[str, RecordValue]) -> bytes: + """Generate a key out of the given values. + + Args: + values: A map of the column names and values to generate a key for. + """ + key_buf = [] + key_remaining = self._key_most + + for column in self.columns: + if column.name not in values: + break + + key_part = encode_key(self, column, values[column.name], self._var_seg_mac) + key_buf.append(key_part) + key_remaining -= len(key_part) + + if key_remaining <= 0: + break + + key = b"".join(key_buf) + if key_remaining < 0: + key = key[: self._key_most] + return key + + +bPrefixNull = 0x00 +bPrefixZeroLength = 0x40 +bPrefixNullHigh = 0xC0 +bPrefixData = 0x7F +bSentinel = 0xFF + + +def encode_key(index: Index, column: Column, value: RecordValue, max_size: int) -> bytes: + """Encode various values into their normalized index key form. + + Args: + column: The column of the value to encode. + value: The value that needs encoding. + max_size: The maximum key segment size. + """ + if value is None: + return bytes([bPrefixNull]) + + # All keys with data are prefixed with 0x7f (bPrefixData) + # There are other prefixes but we don't support those yet + key = bytearray([bPrefixData]) + + if column.type == JET_coltyp.Bit: + key.append(0xFF if value else 0x00) + + elif column.type == JET_coltyp.UnsignedByte: + key.append(value) + + elif column.type == JET_coltyp.Short: + # Signed integers have their MSB bit flipped + key += struct.pack(">H", (value ^ (1 << 15)) & 0xFFFF) + + elif column.type == JET_coltyp.Long: + key += struct.pack(">I", (value ^ (1 << 31)) & 0xFFFFFFFF) + + elif column.type in (JET_coltyp.Currency, JET_coltyp.LongLong): + key += struct.pack(">Q", (value ^ (1 << 63)) & 0xFFFFFFFFFFFFFFFF) + + elif column.type == JET_coltyp.IEEESingle: + value = struct.unpack("I", value) + + elif column.type in (JET_coltyp.IEEEDouble, JET_coltyp.DateTime): + if column.type == JET_coltyp.IEEEDouble: + value = struct.unpack("Q", value) + + elif column.is_binary: + key += _encode_binary(column, value, max_size) + + elif column.is_text: + key += _encode_text(index, column, value, max_size) + + elif column.type == JET_coltyp.UnsignedLong: + # Unsigned variants are added as is + key += struct.pack(">I", value) + + elif column.type == JET_coltyp.GUID: + key += _encode_guid(value) + + elif column.type == JET_coltyp.UnsignedShort: + key += struct.pack(">H", value) + + return bytes(key) + + +def _encode_binary(column: Column, value: bytes, max_size: int) -> bytes: + cbFLDBinaryChunk = 0x08 + cbFLDBinaryChunkNormalized = 0x09 + + key = bytearray() + + if not len(value): + # Empty values (but non null) + key = bytes([bPrefixZeroLength]) + elif column.is_fixed: + # Fixed size binary values are added as is + if len(value) + 1 > max_size: + value = value[:max_size] + key += value + else: + # Otherwise added as chunks of 8 + num_chunks = (len(value) + 7) // 8 + # Each chunk has 1 header byte, and the key has a header byte + key_size = (num_chunks * 9) + 1 + + normalized_all = True + if key_size > max_size: + key_size = max_size + normalized_all = False + + key_remaining = key_size - 1 + + value_offset = 0 + value_remaining = len(value) + while key_remaining >= 9: + chunk = value[value_offset : value_offset + 8] + key += chunk + + if value_remaining <= 8: + # Last chunk + if value_remaining == 8: + key.append(cbFLDBinaryChunk if normalized_all else cbFLDBinaryChunkNormalized) + else: + # Pad to 8 bytes + key.extend([0] * (8 - len(chunk))) + key.append(len(chunk)) + else: + key.append(cbFLDBinaryChunkNormalized) + value_offset += 8 + value_remaining -= 8 + + key_remaining -= 9 + + if key_remaining: + if value_remaining >= key_remaining: + key += value[value_offset : value_offset + key_remaining] + else: + key += value[value_offset : value_offset + value_remaining] + key.extend([0] * (key_remaining - value_remaining)) + + return bytes(key) + + +def _encode_text(index: Index, column: Column, value: str, max_size: int) -> bytes: + key = bytearray() + + if not len(value): + # Empty values (but non null) are indicated with 0x40 + key = bytes([bPrefixZeroLength]) + elif column.encoding in (CODEPAGE.ASCII, CODEPAGE.WESTERN): + # ASCII strings == uppercase + if len(value) + 1 > max_size: + value = value[:max_size] + key += value.upper().encode() + key.append(0) + else: + # Unicode strings == LCMapStringW + flags = index.record.get("LCMapFlags") + locale = index.record.get("LocaleName").decode("utf-16-le") + segment = map_string(value, flags, locale) + key += segment[:max_size] + + return bytes(key) + + +def _encode_guid(value: str | uuid.UUID) -> bytes: + if isinstance(value, str): + value = uuid.UUID(value) + guid_bytes = value.bytes_le + + return guid_bytes[-6:] + guid_bytes[-8:-6] + guid_bytes[-10:-8] + guid_bytes[-12:-10] + guid_bytes[:-12] + + +def _flip_bits(value: int, size: int) -> int: + if value & (1 << (size - 1)): + # If the high bit is set, all bits are flipped + return ~value & ((1 << size) - 1) + # Otherwise only the high bit is flipped + return value ^ (1 << (size - 1)) diff --git a/dissect/database/ese/lcmapstring.py b/dissect/database/ese/lcmapstring.py new file mode 100644 index 0000000..6940787 --- /dev/null +++ b/dissect/database/ese/lcmapstring.py @@ -0,0 +1,218 @@ +# Based on Wine source +# https://github.com/wine-mirror/wine/blob/master/dlls/kernelbase/locale.c + +from enum import IntEnum, IntFlag + +from dissect.util.xmemoryview import xmemoryview + +from dissect.database.ese.sorting_table import table + + +class MapFlags(IntFlag): + NORM_IGNORECASE = 0x00000001 # ignore case + NORM_IGNORENONSPACE = 0x00000002 # ignore nonspacing chars + NORM_IGNORESYMBOLS = 0x00000004 # ignore symbols + + LINGUISTIC_IGNORECASE = 0x00000010 # linguistically appropriate 'ignore case' + LINGUISTIC_IGNOREDIACRITIC = 0x00000020 # linguistically appropriate 'ignore nonspace' + + NORM_IGNOREKANATYPE = 0x00010000 # ignore kanatype + NORM_IGNOREWIDTH = 0x00020000 # ignore width + NORM_LINGUISTIC_CASING = 0x08000000 # use linguistic rules for casing + + LCMAP_LOWERCASE = 0x00000100 # lower case letters + LCMAP_UPPERCASE = 0x00000200 # UPPER CASE LETTERS + LCMAP_TITLECASE = 0x00000300 # Title Case Letters + + LCMAP_SORTKEY = 0x00000400 # WC sort key (normalize) + LCMAP_BYTEREV = 0x00000800 # byte reversal + + LCMAP_HIRAGANA = 0x00100000 # map katakana to hiragana + LCMAP_KATAKANA = 0x00200000 # map hiragana to katakana + LCMAP_HALFWIDTH = 0x00400000 # map double byte to single byte + LCMAP_FULLWIDTH = 0x00800000 # map single byte to double byte + + LCMAP_LINGUISTIC_CASING = 0x01000000 # use linguistic rules for casing + + LCMAP_SIMPLIFIED_CHINESE = 0x02000000 # map traditional chinese to simplified chinese + LCMAP_TRADITIONAL_CHINESE = 0x04000000 # map simplified chinese to traditional chinese + + LCMAP_SORTHANDLE = 0x20000000 + LCMAP_HASH = 0x00040000 + + SORT_STRINGSORT = 0x00001000 # use string sort method + SORT_DIGITSASNUMBERS = 0x00000008 # use digits as numbers sort method + + +class SCRIPT(IntEnum): + UNSORTABLE = 0 + NONSPACE_MARK = 1 + EXPANSION = 2 + EASTASIA_SPECIAL = 3 + JAMO_SPECIAL = 4 + EXTENSION_A = 5 + PUNCTUATION = 6 + SYMBOL_1 = 7 + SYMBOL_2 = 8 + SYMBOL_3 = 9 + SYMBOL_4 = 10 + SYMBOL_5 = 11 + SYMBOL_6 = 12 + DIGIT = 13 + LATIN = 14 + GREEK = 15 + CYRILLIC = 16 + KANA = 34 + HEBREW = 40 + ARABIC = 41 + PUA_FIRST = 169 + PUA_LAST = 175 + CJK_FIRST = 192 + CJK_LAST = 239 + + +class CASE(IntFlag): + FULLWIDTH = 0x01 # full width kana (vs. half width) + FULLSIZE = 0x02 # full size kana (vs. small) + SUBSCRIPT = 0x08 # sub/super script + UPPER = 0x10 # upper case + KATAKANA = 0x20 # katakana (vs. hiragana) + COMPR_2 = 0x40 # compression exists for >= 2 chars + COMPR_4 = 0x80 # compression exists for >= 4 chars + COMPR_6 = 0xC0 # compression exists for >= 6 chars + + +def map_string(value: str, flags: MapFlags, locale: str) -> bytes: + """Very basic Python implementation of LCMapStringEx, only supporting sorting keys. + + Currently only supports one hardcoded sorting table (the default) and the basic character types. + + Args: + value: The string to map to a sorting key. + flags: The flags passed to LCMapStringEx + locale: The locale to use for mapping. + + Returns: + A sorting key of the given input that should be compatible with LCMapStringEx. + + Raises: + NotImplementedError: If an unsupported flag or character is encountered. + """ + key_primary = [] + key_diacritic = [] + key_case = [] + + if not flags & MapFlags.LCMAP_SORTKEY: + raise NotImplementedError("Only LCMAP_SORTKEY is partially supported") + + case_mask = 0x3F + if flags & MapFlags.NORM_IGNORECASE: + case_mask &= ~(CASE.UPPER | CASE.SUBSCRIPT) + if flags & MapFlags.NORM_IGNOREWIDTH: + case_mask &= ~CASE.FULLWIDTH + if flags & MapFlags.NORM_IGNOREKANATYPE: + case_mask &= ~CASE.KATAKANA + + view = xmemoryview(value.encode("utf-16-le"), "> 24 + script_member = (weight >> 16) & 0xFF + diacritic_weight = (weight >> 8) & 0xFF + case_weight = (weight & 0xFF) & case_mask + + if script_member == SCRIPT.UNSORTABLE: + continue + + if script_member == SCRIPT.NONSPACE_MARK: + if flags & MapFlags.LINGUISTIC_IGNOREDIACRITIC: + diacritic_weight = 2 + + if key_diacritic: + key_diacritic[-1] += diacritic_weight + else: + key_diacritic.append(diacritic_weight) + + if script_member == SCRIPT.EXPANSION: + raise NotImplementedError(SCRIPT.EXPANSION) + + if script_member == SCRIPT.EASTASIA_SPECIAL: + raise NotImplementedError(SCRIPT.EASTASIA_SPECIAL) + + if script_member == SCRIPT.JAMO_SPECIAL: + raise NotImplementedError(SCRIPT.JAMO_SPECIAL) + + if script_member == SCRIPT.EXTENSION_A: + key_primary.append(0xFD) + key_primary.append(0xFF) + key_primary.append(alphabetic_weight) + key_primary.append(diacritic_weight) + key_diacritic.append(2) + key_case.append(2) + continue + + if script_member == SCRIPT.PUNCTUATION: + if flags & MapFlags.NORM_IGNORESYMBOLS: + continue + + if not flags & MapFlags.SORT_STRINGSORT: + raise NotImplementedError(SCRIPT.PUNCTUATION) + + key_primary.append(script_member) + key_primary.append(alphabetic_weight) + key_diacritic.append(diacritic_weight) + key_case.append(case_weight) + continue + + if script_member in ( + SCRIPT.SYMBOL_1, + SCRIPT.SYMBOL_2, + SCRIPT.SYMBOL_3, + SCRIPT.SYMBOL_4, + SCRIPT.SYMBOL_5, + SCRIPT.SYMBOL_6, + ): + if flags & MapFlags.NORM_IGNORESYMBOLS: + continue + key_primary.append(script_member) + key_primary.append(alphabetic_weight) + key_diacritic.append(diacritic_weight) + key_case.append(case_weight) + continue + + if script_member == SCRIPT.DIGIT: + raise NotImplementedError(SCRIPT.DIGIT) + + # else + key_primary.append(script_member) + key_primary.append(alphabetic_weight) + key_diacritic.append(diacritic_weight) + key_case.append(case_weight) + + key_diacritic = _filter_weights(key_diacritic) + key_case = [] if flags & (MapFlags.NORM_IGNORECASE | MapFlags.NORM_IGNOREWIDTH) else _filter_weights(key_case) + + return bytes( + [ + *key_primary, + 0x01, + *(key_diacritic if not flags & MapFlags.NORM_IGNORENONSPACE else []), + 0x01, + *key_case, + 0x01, + # extra would go here + 0x01, + # special would go here + 0x00, + ] + ) + + +def _filter_weights(weights: list[int]) -> list[int]: + i = len(weights) + while i > 0: + if weights[i - 1] > 2: + break + i -= 1 + return weights[:i] diff --git a/dissect/database/ese/page.py b/dissect/database/ese/page.py new file mode 100644 index 0000000..28b942b --- /dev/null +++ b/dissect/database/ese/page.py @@ -0,0 +1,270 @@ +from __future__ import annotations + +import struct +from functools import cached_property +from typing import TYPE_CHECKING + +from dissect.database.ese.c_ese import PAGE_FLAG, TAG_FLAG, c_ese + +if TYPE_CHECKING: + from collections.abc import Iterator + + from dissect.database.ese.ese import ESE + + +class Page: + """Represents a logical page of an ESE database. + + Args: + db: An instance of :class:`~dissect.database.ese.ese.ESE`. + num: The logical page number. + buf: The physical page data. + """ + + def __init__(self, db: ESE, num: int, buf: bytes): + self.db = db + self.num = num + self.buf = memoryview(buf) + + data_start = len(c_ese.PGHDR) + self.header = c_ese.PGHDR(self.buf) + self.header2 = None + if not self.is_small_page: + # Large pages have some additional header fields + self.header2 = c_ese.PGHDR2(self.buf[data_start:]) + data_start += len(c_ese.PGHDR2) + + self.flags = self.header.fFlags + self.previous_page = self.header.pgnoPrev + self.next_page = self.header.pgnoNext + + data_end = self.header.ibMicFree + self.data = self.buf[data_start : data_start + data_end] + + # On newer versions, itagMicFree was renamed to itagState and + # now includes a reserved tag count in the upper 4 bits + self.tag_reserved = (self.header.itagState >> 12) or 1 + self.tag_count = self.header.itagState & 0x0FFF + self.node_count = self.tag_count - self.tag_reserved + self._node_cls = LeafNode if self.is_leaf else BranchNode + self._node_cache = {} + + @cached_property + def is_small_page(self) -> bool: + return self.db.has_small_pages + + @cached_property + def is_root(self) -> bool: + return bool(self.flags & PAGE_FLAG.Root) + + @cached_property + def is_leaf(self) -> bool: + return bool(self.flags & PAGE_FLAG.Leaf) + + @cached_property + def is_parent(self) -> bool: + return bool(self.flags & PAGE_FLAG.ParentOfLeaf) + + @cached_property + def is_empty(self) -> bool: + return bool(self.flags & PAGE_FLAG.Empty) + + @cached_property + def is_space_tree(self) -> bool: + return bool(self.flags & PAGE_FLAG.SpaceTree) + + @cached_property + def is_index(self) -> bool: + return bool(self.flags & PAGE_FLAG.Index) + + @cached_property + def is_long_value(self) -> bool: + return bool(self.flags & PAGE_FLAG.LongValue) + + @cached_property + def is_branch(self) -> bool: + return not self.is_leaf + + @cached_property + def key_prefix(self) -> bytes | None: + if not self.is_root: + return bytes(self.tag(0).data) + + return None + + def tag(self, num: int) -> Tag: + """Retrieve a tag by index. + + Args: + num: The tag number to retrieve. + + Raises: + IndexError: If the tag number is out of bounds. + """ + if num < 0 or num > self.tag_count - 1: + raise IndexError(f"Tag number exceeds boundaries: 0-{self.tag_count - 1}") + + return Tag(self, num) + + def tags(self) -> Iterator[Tag]: + """Yield all tags.""" + for i in range(1, self.tag_count): + yield self.tag(i) + + def node(self, num: int) -> BranchNode | LeafNode: + """Retrieve a node by index. + + Nodes are just tags, but indexed from the first tag. + + Args: + num: The node number to retrieve. + + Raises: + IndexError: If the node number is out of bounds. + """ + if num < 0 or num > self.node_count - 1: + raise IndexError(f"Node number exceeds boundaries: 0-{self.node_count - 1}") + + if num not in self._node_cache: + self._node_cache[num] = self._node_cls(self.tag(num + 1)) + + return self._node_cache[num] + + def nodes(self) -> Iterator[BranchNode | LeafNode]: + """Yield all nodes.""" + for i in range(self.node_count): + yield self.node(i) + + def iter_leaf_nodes(self) -> Iterator[LeafNode]: + """Walk the page tree and yield leaf nodes. + + Two methods can be used, one is to travel down to the first leaf, and keep reading ``next_page``'s, + the other is to traverse the tree branches. + + Impacket uses the first method, but gets caught in an infinite loop on some dirty databases. + Traversing the branches seems safer, at the risk of missing a couple (possibly corrupt) pages. + + For this reason, we actually explicitly check if the last page we parse has a ``next_page`` attribute, + and also parse that. This methods seems to work so far. + """ + db = self.db + leaf = None + + for node in self.nodes(): + if self.is_leaf: + yield node + else: + child = db.page(node.child) + for leaf in child.iter_leaf_nodes(): + yield leaf + + if self.is_root and leaf and leaf.tag.page.next_page: + yield from db.page(leaf.tag.page.next_page).iter_leaf_nodes() + + def __repr__(self) -> str: + return f"" + + +class Tag: + """A tag is the "physical" data entry of a page. + + Args: + page: The :class:`Page` this tag is in. + num: The tag number to parse. + """ + + __slots__ = ("data", "flags", "num", "offset", "page", "size", "tag") + + def __init__(self, page: Page, num: int): + self.page = page + self.num = num + + tag_offset = len(page.buf) + ((num + 1) * -4) + tag_buf = page.buf[tag_offset : tag_offset + 4] + + self.tag = c_ese.TAG(tag_buf) + + mask = 0x1FFF if page.is_small_page else 0x7FFF + self.size = self.tag.cb_ & mask + self.offset = self.tag.ib_ & mask + + if self.size == 0 and self.num != 0: + raise ValueError("Invalid TAG data, corrupt database?") + + self.data = self.page.data[self.offset : self.offset + self.size] + + flags = 0 + if page.is_small_page: + # Small pages have the flag in the tag + flags = self.tag.ib_ >> 13 + elif len(self.data) >= 2: + # Large pages have the flag in the first USHORT + # Also in the 3 MSB, just like the small page, but we know it'll be little endian so do a shortcut on + # the second byte. + flags = self.data[1] >> 5 + + self.flags = TAG_FLAG(flags) + + def __repr__(self) -> str: + return f"" + + +class Node: + """A node is the "logical" data entry of a page. + + Args: + tag: The :class:`Tag` to parse a node from. + """ + + __slots__ = ("data", "key", "key_prefix", "key_suffix", "num", "tag") + + def __init__(self, tag: Tag): + self.tag = tag + self.num = tag.num - 1 + + buf = tag.data + offset = 0 + + key_prefix = b"" + key_prefix_size = None + + # Large pages have the tag flags encoded in the 3 MSB of the first word, so we have to mask the first 13 bits + # See also the Tag class + if len(buf) >= offset + 2 and tag.flags & TAG_FLAG.Compressed: + key_prefix_size = struct.unpack("= offset + 2: + key_suffix_size = struct.unpack(" str: + return f"" + + +class BranchNode(Node): + """Special branch node. Parses the child page information.""" + + __slots__ = ("child",) + + def __init__(self, tag: Tag): + super().__init__(tag) + self.child = struct.unpack(" str: + return f"" diff --git a/dissect/database/ese/record.py b/dissect/database/ese/record.py new file mode 100644 index 0000000..76592a7 --- /dev/null +++ b/dissect/database/ese/record.py @@ -0,0 +1,515 @@ +from __future__ import annotations + +import functools +import struct +from binascii import hexlify +from functools import lru_cache +from typing import TYPE_CHECKING, Any + +from dissect.util.xmemoryview import xmemoryview + +from dissect.database.ese import compression +from dissect.database.ese.c_ese import PAGE_FLAG, TAGFLD_HEADER, c_ese + +if TYPE_CHECKING: + from collections.abc import Iterator + + from dissect.database.ese.page import Node + from dissect.database.ese.table import Column, Table + from dissect.database.ese.util import RecordValue + + +def noop(value: Any) -> Any: + return value + + +class Record: + """Wrapper class for records in a table. + + The actual parsing of the data is done in :class:`RecordData`, but this class allows you to easily + retrieve all the values by either using the `.get()` method, accessing them as attributes or dictionary keys + on this class. + + Args: + table: The table this record is from. + node: The node of this record. + """ + + def __init__(self, table: Table, node: Node): + self._table = table + self._db = table.db + self._node = node + self._data = RecordData(table, node) + + def __str__(self) -> str: + column_values = serialise_record_column_values(self, max_columns=None) + return f"" + + def __repr__(self) -> str: + column_values = serialise_record_column_values(self) + return f"" + + def __hash__(self) -> int: + return hash((self._table, self._node)) + + def __getitem__(self, attr: str) -> RecordValue: + return self.get(attr) + + def __getattr__(self, attr: str) -> RecordValue: + try: + return self.get(attr) + except KeyError: + return object.__getattribute__(self, attr) + + def __eq__(self, value: object) -> bool: + if not isinstance(value, Record): + return False + + return self._node.key == value._node.key + + def __ne__(self, value: object) -> bool: + if not isinstance(value, Record): + return False + + return self._node.key != value._node.key + + def __lt__(self, value: object) -> bool: + if not isinstance(value, Record): + return False + + return self._node.key < value._node.key + + def __le__(self, value: object) -> bool: + if not isinstance(value, Record): + return False + + return self._node.key <= value._node.key + + def __gt__(self, value: object) -> bool: + if not isinstance(value, Record): + return False + + return self._node.key > value._node.key + + def __ge__(self, value: object) -> bool: + if not isinstance(value, Record): + return False + + return self._node.key >= value._node.key + + def get(self, attr: str, raw: bool = False) -> RecordValue: + """Retrieve a value from the record with the given name. + + Optionally receive the raw data as it's stored in the record. + + Args: + attr: The column name to retrieve the value of. + raw: Whether to return the raw data stored in the record instead of the parsed value. + """ + column = self._table.column(attr) + return self._data.get(column, raw) + + def as_dict(self, raw: bool = False) -> dict[str, RecordValue]: + return self._data.as_dict(raw) + + +class RecordData: + """Record class for parsing and interacting with the on-disk record format. + + Templated columns are currently not implemented. + + Args: + table: The table this record is from. + data: The node data of this record. + + Raises: + NotImplementedError: If old format tagged fields are encountered. + """ + + def __init__(self, table: Table, node: Node): + self.table = table + self.db = table.db + self.node = node + self.data = node.data + + self.header = None + self._values = {} + + self._last_fixed_id = None + self._last_variable_id = None + + self._fixed_null_bitmap = None + + self._variable_offset_start = None + self._variable_data_start = None + self._variable_offsets = [] + + self._tagged_data_start = None + self._tagged_data_count = 0 + self._tagged_data_view = None + self._tagged_fields = {} + + if len(self.data) >= 4: + self.header = c_ese.RECHDR(self.data) + self._last_fixed_id = self.header.fidFixedLastInRec + self._last_variable_id = self.header.fidVarLastInRec + self._variable_offset_start = self.header.ibEndOfFixedData + + # There's a bitmap between the end of the fixed data and the start of variable data that indicates + # if a fixed column is null. + bitmap_start = self._variable_offset_start - ((self._last_fixed_id + 7) // 8) + self._fixed_null_bitmap = self.data[bitmap_start : self._variable_offset_start] + + # Calculate where the variable offsets array and data start + # This info is needed for parsing both variable and tagged data + # Variable identifiers start from 128 + num_variable = self._last_variable_id - 127 + # Variable offset end == variable data start + self._variable_data_start = self._variable_offset_start + (num_variable * 2) + + if num_variable > 0 and len(self.data) >= 4 + (num_variable * 2): + # Parse the variable offsets already, if we have them + # There can only be 128 at most, so this shouldn't be an expensive operation + self._variable_offsets = struct.unpack( + f"<{num_variable}H", self.data[self._variable_offset_start : self._variable_data_start] + ) + + self._tagged_data_start = self._variable_data_start + if self._variable_offsets: + self._tagged_data_start += self._variable_offsets[-1] & 0x7FFF + + if len(self.data) >= self._tagged_data_start + 4: + if node.tag.page.flags & PAGE_FLAG.NewRecordFormat == 0: + raise NotImplementedError("Record has tagged fields in an old format, which is not implemented yet") + + tag_value = int.from_bytes(self.data[self._tagged_data_start : self._tagged_data_start + 4], "little") + first_tagged_field = TagField(self, tag_value) + + tagged_field_data_start = self._tagged_data_start + tagged_field_data_end = tagged_field_data_start + first_tagged_field.offset + tagged_field_data = self.data[self._tagged_data_start : tagged_field_data_end] + + self._tagged_data_count = first_tagged_field.offset // 4 # sizeof(TAGFLD) + self._tagged_data_view = xmemoryview(tagged_field_data, " RecordValue: + """Retrieve the value for the specified column. + + Optionally receive the raw data as it's stored in the record. + + If the database has been opened in impacket compatibility mode, skip most of the parsing and return the values + that impacket expects. + + Args: + column: The column to retrieve the value of. + raw: Whether to return the raw data stored in the record instead of the parsed value. + errors: Error handling scheme to use when decoding bytes to text (default: 'backslashreplace'). + """ + value = None + tag_field = None + + if self.header is None: + return value + + if column.is_fixed: + value = self._get_fixed(column) + + elif column.is_variable: + value = self._get_variable(column) + + elif column.is_tagged: + tag_field, value = self._get_tagged(column) + + if raw: + if isinstance(value, memoryview): + value = value.tobytes() + return value + + if value is not None: + return self._parse_value(column, value, tag_field, errors) + + return None + + def as_dict(self, raw: bool = False, errors: str | None = "backslashreplace") -> dict[str, RecordValue]: + """Serialize the record as a dictionary.""" + obj = {} + + def _iter_column_id() -> Iterator[Column]: + # Fixed + yield from range(1, self._last_fixed_id + 1) + + # Variable + yield from range(128, self._last_variable_id + 1) + + # Tagged + for idx in range(self._tagged_data_count): + yield self._get_tag_field(idx).identifier + + for column_id in _iter_column_id(): + column = self.table._column_id_map[column_id] + + try: + obj[column.name] = self.get(column, raw, errors) + except Exception as e: + obj[column.name] = f"!ERROR! {e}" + + return obj + + def _parse_value( + self, column: Column, value: bytes, tag_field: TagField = None, errors: str | None = "backslashreplace" + ) -> RecordValue: + """Parse the raw value into the appropriate type. + + For tagged columns, also interpret things like multi-values, separated and compressed data. + """ + ctype = column.ctype + parse_func = ctype.parse + if column.is_text: + parse_func = functools.partial(ctype.parse, encoding=column.encoding, errors=errors) + + if self.db.impacket_compat: + if tag_field and tag_field.flags & TAGFLD_HEADER.Compressed: + value = None + elif tag_field and tag_field.flags & TAGFLD_HEADER.MultiValues: + value = hexlify(value) + elif parse_func is not bytes: + value = parse_func(value) + else: + value = hexlify(value) + else: + if tag_field: + if tag_field.flags & TAGFLD_HEADER.MultiValues: + value = self._parse_multivalue(value, tag_field) + else: + if tag_field.flags & TAGFLD_HEADER.Separated: + value = self.table.get_long_value(bytes(value)) + elif tag_field.flags & TAGFLD_HEADER.Compressed: + # Long values are already decompressed during retrieval + value = compression.decompress(value) + + parse_func = parse_func or noop + if tag_field and tag_field.flags & TAGFLD_HEADER.MultiValues: + value = list(map(parse_func, value)) + else: + value = parse_func(value) + + return value + + def _parse_multivalue(self, value: bytes, tag_field: TagField) -> list[bytes]: + fSeparatedInstance = 0x8000 + + if tag_field.flags & TAGFLD_HEADER.TwoValues: + # Optimized storage for when a multi-value only has two values + # First byte is the size of the first value, calculate the size of the second value from that + first_size = value[0] + second_size = len(value) - (1 + first_size) + value = [value[1 : 1 + first_size], value[1 + first_size : 1 + first_size + second_size]] + elif tag_field.flags & TAGFLD_HEADER.MultiValues: + # Regular multi-value storage, starts with an array of USHORT offsets to the actual values + # Just calculate the amount of values from the first entry + # Individual offsets can have a fSeparatedInstance (0x8000) flag set + first_value_offset = struct.unpack(" bytes | None: + """Parse a specific fixed column.""" + if column.identifier <= self._last_fixed_id: + # Check if it's not null + bit_idx_identifier = column.identifier - 1 + bitmap_offset, bitmap_shift = divmod(bit_idx_identifier, 8) + if self._fixed_null_bitmap[bitmap_offset] & (1 << bitmap_shift): + return None + + # Fixed data starts right after the header, which is 4 bytes + offset = 4 + column.offset + value = self.data[offset : offset + column.size] + else: + # If the column has a default, use that + # If not, this defaults to None + value = column.default + + return value + + def _get_variable(self, column: Column) -> bytes | None: + """Parse a specific variable column.""" + if column.identifier <= self._last_variable_id: + identifier_idx = column.identifier - 128 + + # Start of this value is the end of the previous value + # Even empty values have the offset encoded in them + value_start = 0 if identifier_idx == 0 else self._variable_offsets[identifier_idx - 1] & 32767 + + # The value at the own index is the end offset of this value + value_end = self._variable_offsets[identifier_idx] + + # If the MSB has been set, it means the entry is empty + if value_end & 0x8000 == 0: + # Offset everything with the variable data value starting offset + value_offset = self._variable_data_start + value = self.data[value_offset + value_start : value_offset + value_end] + else: + value = None + else: + # If the column has a default, use that + # If not, this defaults to None + value = column.default + + return value + + def _get_tagged(self, column: Column) -> bytes | None: + """Parse a specific tagged column.""" + tag_field = None + + idx = self._find_tag_field_idx(column.identifier) + if idx is not None: + tag_field = self._get_tag_field(idx) + + data_start = tag_field.offset + if tag_field.has_extended_info: + data_start += 1 + + data_end = self._get_tag_field(idx + 1).offset if idx + 1 < self._tagged_data_count else len(self.data) + + if not tag_field.is_null: + offset = self._tagged_data_start + value = self.data[offset + data_start : offset + data_end] + else: + # If the column has a default, use that + # If not, this defaults to None + value = column.default + + return tag_field, value + + def _get_tag_field(self, idx: int) -> TagField: + """Retrieve the :class:`TagField` at the given index in the ``TAGFLD`` array.""" + return TagField(self, self._tagged_data_view[idx]) + + def _find_tag_field_idx(self, identifier: int, is_derived: bool = False) -> TagField | None: + """Find a tag field by identifier and optional derived flag. + + Performs a binary search in the tagged field array for the given identifier. The comparison algorithm used is + derived from the ``TAGFLD::CmpTagfld2`` function in the Microsoft codebase. + + Args: + identifier: The column identifier to look for. + is_derived: A flag indicating if the column is derived. + + Returns: + A :class:`TagField` object for the found tag field, or ``None`` if it's not found. + """ + if self._tagged_data_count == 0: + return None + + lookup = identifier + if is_derived: + lookup |= TagField.fDerived << 16 # fDerived + + # TAGFLD::CmpTagfld2 + flip_derived = TagField.fDerived << 16 + mask = flip_derived | ((1 << 16) - 1) + value2 = flip_derived ^ (lookup & mask) + + min_idx = 0 + max_idx = self._tagged_data_count - 1 + + while min_idx != max_idx: + test_idx = min_idx + (max_idx - min_idx) // 2 + + tag_value = self._tagged_data_view[test_idx] + value1 = flip_derived ^ (tag_value & mask) + if value1 < value2: + min_idx = test_idx + 1 + elif value1 == value2: + min_idx = test_idx + break + else: + max_idx = test_idx + + tag_value = self._tagged_data_view[min_idx] + if tag_value & 0xFFFF == identifier: + return min_idx + + return None + + +class TagField: + """Represents a ``TAGFLD``, which contains information about a tagged field in a record.""" + + __slots__ = ("_offset", "flags", "has_extended_info", "identifier", "offset", "record") + + fNullSmallPage = 0x2000 + fDerived = 0x8000 + + def __init__(self, record: RecordData, value: int): + self.record = record + self.identifier = value & 0xFFFF + self._offset = (value >> 16) & 0xFFFF + + if record.db.has_small_pages: + self.offset = self._offset & 0x1FFF # & maskIb + self.has_extended_info = bool(self._offset & 0x4000) # & fExtendedInfo + else: + self.offset = self._offset & 0x7FFF # & maskIb + self.has_extended_info = True + + if self.has_extended_info and len(self.record.data) >= self.record._tagged_data_start + self.offset: + self.flags = TAGFLD_HEADER(self.record.data[self.record._tagged_data_start + self.offset]) + else: + self.flags = TAGFLD_HEADER.Invalid # Made up flag member to keep the types consistent + + def __repr__(self) -> str: + return f"" + + @property + def is_null(self) -> bool: + """Return whether this tagged field is null.""" + if self.record.db.has_small_pages: + return bool(self._offset & TagField.fNullSmallPage) + return bool(self.flags & TAGFLD_HEADER.Null) + + @property + def is_derived(self) -> bool: + """Return whether this tagged field is derived.""" + return bool(self._offset & TagField.fDerived) + + +def serialise_record_column_values(record: Record, column_names: list[str] | None = None, max_columns: int = 10) -> str: + column_names = column_names or record._table.column_names + columns_with_values = [] + for name in column_names: + try: + value = record.get(name) + except Exception: + value = "!ERROR!" + + if value is not None: + columns_with_values.append((name, value)) + + if max_columns and len(columns_with_values) >= max_columns: + break + + reprs = " ".join([f"{name}={value!r}" for (name, value) in columns_with_values]) + has_more = " ..." if max_columns and len(column_names) > max_columns else "" + return f"{reprs}{has_more}" diff --git a/dissect/database/ese/sorting_table.py b/dissect/database/ese/sorting_table.py new file mode 100644 index 0000000..4d7f1fa --- /dev/null +++ b/dissect/database/ese/sorting_table.py @@ -0,0 +1,8198 @@ +# flake8: noqa +# Generated from https://download.microsoft.com/download/C/F/7/CF713A5E-9FBC-4FD6-9246-275F65C0E498/Windows%2010%20Sorting%20Weight%20Table.txt + +# fmt: off +table = [ + 0x00000000, 0x03060202, 0x04060202, 0x05060202, 0x06060202, 0x07060202, 0x08060202, 0x09060202, + 0x0a060202, 0x05070202, 0x06070202, 0x07070202, 0x08070202, 0x09070202, 0x0b060202, 0x0c060202, + 0x0d060202, 0x0e060202, 0x0f060202, 0x10060202, 0x11060202, 0x12060202, 0x13060202, 0x14060202, + 0x15060202, 0x16060202, 0x17060202, 0x18060202, 0x19060202, 0x1a060202, 0x1b060202, 0x1c060202, + 0x02070202, 0x1c070202, 0x1d070202, 0x1f070202, 0x21070202, 0x23070202, 0x25070202, 0x80060202, + 0x27070202, 0x2a070202, 0x2d070202, 0x03080202, 0x2f070202, 0x82060202, 0x33070202, 0x35070202, + 0x030d0202, 0x1a0d0202, 0x1c0d0202, 0x1e0d0202, 0x200d0202, 0x220d0202, 0x240d0202, 0x260d0202, + 0x280d0202, 0x2a0d0202, 0x37070202, 0x3a070202, 0x0e080202, 0x12080202, 0x14080202, 0x3c070202, + 0x3e070202, 0x020e0212, 0x090e0212, 0x0a0e0212, 0x1a0e0212, 0x210e0212, 0x230e0212, 0x250e0212, + 0x2c0e0212, 0x320e0212, 0x350e0212, 0x360e0212, 0x480e0212, 0x510e0212, 0x700e0212, 0x7c0e0212, + 0x7e0e0212, 0x890e0212, 0x8a0e0212, 0x910e0212, 0x990e0212, 0x9f0e0212, 0xa20e0212, 0xa40e0212, + 0xa60e0212, 0xa70e0212, 0xa90e0212, 0x3f070202, 0x41070202, 0x42070202, 0x43070202, 0x44070202, + 0x48070202, 0x020e0202, 0x090e0202, 0x0a0e0202, 0x1a0e0202, 0x210e0202, 0x230e0202, 0x250e0202, + 0x2c0e0202, 0x320e0202, 0x350e0202, 0x360e0202, 0x480e0202, 0x510e0202, 0x700e0202, 0x7c0e0202, + 0x7e0e0202, 0x890e0202, 0x8a0e0202, 0x910e0202, 0x990e0202, 0x9f0e0202, 0xa20e0202, 0xa40e0202, + 0xa60e0202, 0xa70e0202, 0xa90e0202, 0x4a070202, 0x4c070202, 0x4e070202, 0x50070202, 0x1d060202, + 0xfa0c1d02, 0xfa0c1e02, 0xfa0c1f02, 0xfa0c2002, 0xfa0c2102, 0xfa0c2202, 0xfa0c2302, 0xfa0c2402, + 0xfa0c2502, 0xfa0c2602, 0xfa0c2702, 0xfa0c2802, 0xfa0c2902, 0xfa0c2a02, 0xfa0c2b02, 0xfa0c2c02, + 0xfa0c2d02, 0xfa0c2e02, 0xfa0c2f02, 0xfa0c3002, 0xfa0c3102, 0xfa0c3202, 0xfa0c3302, 0xfa0c3402, + 0xfa0c3502, 0xfa0c3602, 0xfa0c3702, 0xfa0c3802, 0xfa0c3902, 0xfa0c3a02, 0xfa0c3b02, 0xfa0c3c02, + 0x04070202, 0x51070202, 0x97070202, 0x98070202, 0x99070202, 0x9a070202, 0x52070202, 0x060a0202, + 0x53070202, 0x070a0202, 0x020e030e, 0x18080202, 0x080a0202, 0x00000000, 0x090a0202, 0x54070202, + 0x0a0a0202, 0x17080202, 0x1c0d020e, 0x1e0d020e, 0x55070202, 0x0b0a0202, 0x0c0a0202, 0x0d0a0202, + 0x56070202, 0x1a0d020e, 0x7c0e030e, 0x1a080202, 0x0d0d0202, 0x110d0202, 0x150d0202, 0x57070202, + 0x020e0f12, 0x020e0e12, 0x020e1212, 0x020e1912, 0x020e1312, 0x020e1a12, 0x00000000, 0x0a0e1c12, + 0x210e0f12, 0x210e0e12, 0x210e1212, 0x210e1312, 0x320e0f12, 0x320e0e12, 0x320e1212, 0x320e1312, + 0x1a0e6812, 0x700e1912, 0x7c0e0f12, 0x7c0e0e12, 0x7c0e1212, 0x7c0e1912, 0x7c0e1312, 0x1c080202, + 0x7c0e2112, 0x9f0e0f12, 0x9f0e0e12, 0x9f0e1212, 0x9f0e1312, 0xa70e0e12, 0x00000000, 0x00000000, + 0x020e0f02, 0x020e0e02, 0x020e1202, 0x020e1902, 0x020e1302, 0x020e1a02, 0x00000000, 0x0a0e1c02, + 0x210e0f02, 0x210e0e02, 0x210e1202, 0x210e1302, 0x320e0f02, 0x320e0e02, 0x320e1202, 0x320e1302, + 0x1a0e6802, 0x700e1902, 0x7c0e0f02, 0x7c0e0e02, 0x7c0e1202, 0x7c0e1902, 0x7c0e1302, 0x1d080202, + 0x7c0e2102, 0x9f0e0f02, 0x9f0e0e02, 0x9f0e1202, 0x9f0e1302, 0xa70e0e02, 0x00000000, 0xa70e1302, + 0x020e1712, 0x020e1702, 0x020e1512, 0x020e1502, 0x020e1b12, 0x020e1b02, 0x0a0e0e12, 0x0a0e0e02, + 0x0a0e1212, 0x0a0e1202, 0x0a0e1012, 0x0a0e1002, 0x0a0e1412, 0x0a0e1402, 0x1a0e1412, 0x1a0e1402, + 0x1a0e1e12, 0x1a0e1e02, 0x210e1712, 0x210e1702, 0x210e1512, 0x210e1502, 0x210e1012, 0x210e1002, + 0x210e1b12, 0x210e1b02, 0x210e1412, 0x210e1402, 0x250e1212, 0x250e1202, 0x250e1512, 0x250e1502, + 0x250e1012, 0x250e1002, 0x250e1c12, 0x250e1c02, 0x2c0e1212, 0x2c0e1202, 0x2c0e1e12, 0x2c0e1e02, + 0x320e1912, 0x320e1902, 0x320e1712, 0x320e1702, 0x320e1512, 0x320e1502, 0x320e1b12, 0x320e1b02, + 0x320e1012, 0x320e0402, 0x00000000, 0x00000000, 0x350e1212, 0x350e1202, 0x360e1c12, 0x360e1c02, + 0x360e0402, 0x480e0e12, 0x480e0e02, 0x480e1c12, 0x480e1c02, 0x480e1412, 0x480e1402, 0x480e1112, + 0x480e1102, 0x480e1f12, 0x480e1f02, 0x700e0e12, 0x700e0e02, 0x700e1c12, 0x700e1c02, 0x700e1412, + 0x700e1402, 0x700e4802, 0x740e0212, 0x740e0202, 0x7c0e1712, 0x7c0e1702, 0x7c0e1512, 0x7c0e1502, + 0x7c0e1d12, 0x7c0e1d02, 0x00000000, 0x00000000, 0x8a0e0e12, 0x8a0e0e02, 0x8a0e1c12, 0x8a0e1c02, + 0x8a0e1412, 0x8a0e1402, 0x910e0e12, 0x910e0e02, 0x910e1212, 0x910e1202, 0x910e1c12, 0x910e1c02, + 0x910e1412, 0x910e1402, 0x990e1c12, 0x990e1c02, 0x990e1412, 0x990e1402, 0x9e0e1e12, 0x9e0e1e02, + 0x9f0e1912, 0x9f0e1902, 0x9f0e1712, 0x9f0e1702, 0x9f0e1512, 0x9f0e1502, 0x9f0e1a12, 0x9f0e1a02, + 0x9f0e1d12, 0x9f0e1d02, 0x9f0e1b12, 0x9f0e1b02, 0xa40e1212, 0xa40e1202, 0xa70e1212, 0xa70e1202, + 0xa70e1312, 0xa90e0e12, 0xa90e0e02, 0xa90e1012, 0xa90e1002, 0xa90e1412, 0xa90e1402, 0x960e0202, + 0x090e1e02, 0x090e4312, 0x090e6812, 0x090e6802, 0x090e8712, 0x090e8702, 0x0a0e7a12, 0x0a0e4312, + 0x0a0e4302, 0x1b0e0412, 0x1a0e4312, 0x1a0e2212, 0x1a0e2202, 0x1a0e7c02, 0x210e7d12, 0x210e7e12, + 0x220e0212, 0x230e4312, 0x230e4302, 0x250e4312, 0x250e7b12, 0x2d0e5902, 0x320e7b12, 0x320e1e12, + 0x360e4312, 0x360e4302, 0x480e1e02, 0x480e2002, 0x510e7b12, 0x700e4312, 0x700e4b02, 0x7c0e2012, + 0x7c0e5012, 0x7c0e5002, 0x7c0e7c12, 0x7c0e7c02, 0x7e0e4312, 0x7e0e4302, 0x8a0e021c, 0x910e8712, + 0x910e8702, 0x910e7c12, 0x910eaa02, 0x990e5702, 0x990e4312, 0x990e4302, 0x990e5912, 0x9f0e5012, + 0x9f0e5002, 0x9f0e7b12, 0xa20e7b12, 0xa70e4312, 0xa70e4302, 0xa90e1e12, 0xa90e1e02, 0xac0e0212, + 0xac0e7c12, 0xac0e7c02, 0xac0e7d02, 0x1c0d0202, 0x220d0212, 0x220d0202, 0xb30e0202, 0xa40e7b02, + 0x1e080202, 0x1f080202, 0x20080202, 0x58070202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x020e1412, 0x020e1402, 0x320e1412, + 0x320e1402, 0x7c0e1412, 0x7c0e1402, 0x9f0e1412, 0x9f0e1402, 0x9f0e2812, 0x9f0e2802, 0x9f0e1f12, + 0x9f0e1f02, 0x9f0e2512, 0x9f0e2502, 0x9f0e2012, 0x9f0e2002, 0x210e7d02, 0x020e2812, 0x020e2802, + 0x020e2512, 0x020e2502, 0x00000000, 0x00000000, 0x250e1e12, 0x250e1e02, 0x250e1412, 0x250e1402, + 0x360e1412, 0x360e1402, 0x7c0e1b12, 0x7c0e1b02, 0x7c0e3012, 0x7c0e3002, 0xac0e1412, 0xac0e1402, + 0x350e1402, 0x00000000, 0x00000000, 0x00000000, 0x250e0e12, 0x250e0e02, 0x2d0e5912, 0xa40e7b12, + 0x700e0f12, 0x700e0f02, 0x020e2612, 0x020e2602, 0x00000000, 0x00000000, 0x7c0e2d12, 0x7c0e2d02, + 0x020e4412, 0x020e4402, 0x020e4612, 0x020e4602, 0x210e4412, 0x210e4402, 0x210e4612, 0x210e4602, + 0x320e4412, 0x320e4402, 0x320e4612, 0x320e4602, 0x7c0e4412, 0x7c0e4402, 0x7c0e4612, 0x7c0e4602, + 0x8a0e4412, 0x8a0e4402, 0x8a0e4612, 0x8a0e4602, 0x9f0e4412, 0x9f0e4402, 0x9f0e4612, 0x9f0e4602, + 0x910e5b12, 0x910e5b02, 0x990e5b12, 0x990e5b02, 0x220e9712, 0x220e9702, 0x2c0e1412, 0x2c0e1402, + 0x700e4b12, 0x1e0e0202, 0x7d0e0212, 0x7d0e0202, 0xa90e4312, 0xa90e4302, 0x020e1012, 0x020e1002, + 0x210e1c12, 0x210e1c02, 0x7c0e2812, 0x7c0e2802, 0x7c0e2e12, 0x7c0e2e02, 0x7c0e1012, 0x7c0e1002, + 0x7c0e2512, 0x7c0e2502, 0xa70e1712, 0xa70e1702, 0x4a0ec802, 0x720ec802, 0x990ec802, 0x350e0402, + 0x00000000, 0x00000000, 0x020e1c12, 0x0a0e1e12, 0x0a0e1e02, 0x480e1e12, 0x990e6512, 0x910e5c02, + 0xa90e5c02, 0xb30e0312, 0xb30e0302, 0x090e1e12, 0x9f0e1e12, 0xa20e7c12, 0x210e1d12, 0x210e1d02, + 0x350e1d12, 0x350e1d02, 0x890e4512, 0x890e4502, 0x8a0e1d12, 0x8a0e1d02, 0xa70e1d12, 0xa70e1d02, + 0x020e7b02, 0x020e7c02, 0x020e7d02, 0x090e4302, 0x0a0e7a02, 0x0a0e7c02, 0x1b0e0402, 0x1a0e4302, + 0x210e8002, 0x210e7e02, 0x210e7f02, 0x220e0202, 0x220e8002, 0x220e8202, 0x220e8302, 0x350e1e02, + 0x250e4302, 0x250e7d02, 0x250e0216, 0x250e7b02, 0x250e7c02, 0x2c0e7c02, 0x2c0e4302, 0x310e4302, + 0x320e1e02, 0x320e7b02, 0x320e0216, 0x480e1902, 0x480e7b02, 0x480e5902, 0x480e7c02, 0x510e7b02, + 0x510e7c02, 0x510e4302, 0x700e4302, 0x700e5902, 0x700e0216, 0x7c0e2002, 0x7c0e7b16, 0x7c0e7e02, + 0x7e0e7b02, 0x8a0e7b02, 0x8a0e7c02, 0x8a0e7d02, 0x8a0e7e02, 0x8a0e4302, 0x8a0e7f02, 0x8a0e8002, + 0x8a0e0216, 0x8a0e8116, 0x910e4302, 0x910e7c02, 0x350e4302, 0x910ea002, 0x910e9602, 0x990e7b02, + 0x990e5902, 0x9f0e1e02, 0x9f0e7b02, 0xa20e7b02, 0xa20e7c02, 0xa40e7c02, 0xa70e7b02, 0xa70e0216, + 0xa90e5902, 0xa90e7e02, 0xac0e0202, 0xac0e7e02, 0xb30e030a, 0xb30e0402, 0xb30e0502, 0x0a0e8802, + 0xb40e0202, 0x090e0216, 0x220e8602, 0x250e4316, 0x2c0e0216, 0x350e7b02, 0x360e7b02, 0x480e0216, + 0x890e4302, 0xb30e0602, 0xb30e0b02, 0x1c0e0202, 0x1a0e7b02, 0x1d0e0202, 0x9d0e7b02, 0x990e7c02, + 0x990e7d02, 0x00000000, 0x00000000, 0x00000000, 0xb50e0202, 0xb60e0202, 0x2d0e6402, 0x2d0e6e02, + 0x2c0e020a, 0x2c0e430a, 0x350e020a, 0x8a0e020a, 0x8a0e7b0a, 0x8a0e7d0a, 0x8a0e811e, 0xa40e020a, + 0xa70e020a, 0x00010c00, 0x00011900, 0x00014500, 0x00014600, 0x00014700, 0x00017700, 0x00017800, + 0x00013f00, 0x00017900, 0x00017a00, 0x00017b00, 0x00017c00, 0x00017d00, 0x43070202, 0x59070202, + 0x00014000, 0x2d070402, 0x55070302, 0x48070202, 0x00015a00, 0x00016200, 0x00017e00, 0x00017f00, + 0xdb070202, 0x00018100, 0x00018200, 0x00018300, 0x00015000, 0x00015100, 0x00015200, 0x00015300, + 0x59070302, 0x5a070202, 0x5b070202, 0x5c070202, 0x5d070202, 0x5e070202, 0x00018400, 0x00013400, + 0x250e7b0a, 0x480e020a, 0x910e020a, 0xa60e020a, 0x00018500, 0x00018600, 0x00018700, 0x00018800, + 0x00018900, 0x00018a00, 0x00013500, 0x00013600, 0x00013700, 0x00013800, 0x00013900, 0x00013a00, + 0x00013b00, 0x00013c00, 0x00013d00, 0x0001f100, 0x0001f200, 0x0001f300, 0x0001f400, 0x0001f500, + 0x0001f600, 0x0001f700, 0x0001f800, 0x0001f900, 0x0001fa00, 0x0001fb00, 0x0001fb00, 0x0001fc00, + 0x00010d00, 0x00010c00, 0x00011000, 0x00011700, 0x00011500, 0x00013e00, 0x00011300, 0x00010e00, + 0x00011100, 0x00013f00, 0x00011800, 0x00011b00, 0x00011200, 0x00010300, 0x00014100, 0x00014200, + 0x00014300, 0x00014400, 0x00014500, 0x00014600, 0x00014700, 0x00014800, 0x00014900, 0x00014a00, + 0x00014b00, 0x00014c00, 0x00014d00, 0x00014e00, 0x00014f00, 0x00015000, 0x00015100, 0x00015200, + 0x00015300, 0x00015400, 0x00015500, 0x00015600, 0x00015700, 0x00015800, 0x00015900, 0x00011a00, + 0x00011900, 0x00015a00, 0x00015b00, 0x00015c00, 0x00015d00, 0x00015e00, 0x00015f00, 0x00016000, + 0x00016100, 0x00016200, 0x00016300, 0x00016400, 0x00016500, 0x00011c00, 0x00011c00, 0x00011d00, + 0x00011e00, 0x00016700, 0x00016800, 0x00016900, 0x00016a00, 0x00016b00, 0x00016c00, 0x00016d00, + 0x00010d00, 0x00010c00, 0x00018d00, 0x00014600, 0x00011d00, 0x00019000, 0x00017400, 0x00017500, + 0x00017600, 0x00015c00, 0x00015d00, 0x00015e00, 0x00015f00, 0x00016000, 0x00016100, 0x00000000, + 0x00015400, 0x00015500, 0x00015600, 0x00015700, 0x00015800, 0x00015900, 0x00015a00, 0x00015b00, + 0x00011e00, 0x00011f00, 0x00012000, 0x00012100, 0x00012800, 0x00011400, 0x00011500, 0x00011500, + 0x00011700, 0x00014400, 0x00012700, 0x020e0302, 0x210e0302, 0x320e0302, 0x7c0e0302, 0x9f0e0302, + 0x0a0e0302, 0x1a0e0302, 0x2c0e0302, 0x510e0302, 0x8a0e0302, 0x990e0302, 0xa20e0302, 0xa60e0302, + 0x0d0f0212, 0x0d0f0202, 0x460f1b12, 0x460f1b02, 0x00000000, 0x60070202, 0x430f020a, 0x430f0202, + 0x00000000, 0x00000000, 0x61070202, 0x270f0202, 0x260f1002, 0x270f1002, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x63070202, 0x00000000, 0x020f0e12, 0x00000000, + 0x0a0f0e12, 0x0e0f0e12, 0x120f0e12, 0x00000000, 0x200f0e12, 0x00000000, 0x2a0f0e12, 0x320f0e12, + 0x120f1f02, 0x020f0212, 0x040f0212, 0x060f0212, 0x080f0212, 0x0a0f0212, 0x0c0f0212, 0x0e0f0212, + 0x100f0212, 0x120f0212, 0x140f0212, 0x160f0212, 0x180f0212, 0x1c0f0212, 0x1e0f0212, 0x200f0212, + 0x220f0212, 0x240f0212, 0x00000000, 0x260f0212, 0x280f0212, 0x2a0f0212, 0x2c0f0212, 0x2e0f0212, + 0x300f0212, 0x320f0212, 0x120f1312, 0x2a0f1312, 0x020f0e02, 0x0a0f0e02, 0x0e0f0e02, 0x120f0e02, + 0x2a0f1f02, 0x020f0202, 0x040f0202, 0x060f0202, 0x080f0202, 0x0a0f0202, 0x0c0f0202, 0x0e0f0202, + 0x100f0202, 0x120f0202, 0x140f0202, 0x160f0202, 0x180f0202, 0x1c0f0202, 0x1e0f0202, 0x200f0202, + 0x220f0202, 0x240f0202, 0x260f020a, 0x260f0202, 0x280f0202, 0x2a0f0202, 0x2c0f0202, 0x2e0f0202, + 0x300f0202, 0x320f0202, 0x120f1302, 0x2a0f1302, 0x200f0e02, 0x2a0f0e02, 0x320f0e02, 0x450f0212, + 0x040f0302, 0x100f0302, 0x2a0f1b12, 0x2a0f2712, 0x2a0f2c12, 0x2c0f0302, 0x220f0302, 0x450f0202, + 0x440f1b12, 0x440f1b02, 0x400f0212, 0x400f0202, 0x420f0212, 0x420f0202, 0x440f0212, 0x440f0202, + 0x460f0212, 0x460f0202, 0x480f0212, 0x480f0202, 0x4a0f0212, 0x4a0f0202, 0x4c0f0212, 0x4c0f0202, + 0x4e0f0212, 0x4e0f0202, 0x500f0212, 0x500f0202, 0x520f0212, 0x520f0202, 0x540f0212, 0x540f0202, + 0x140f0302, 0x240f0302, 0x260f0402, 0x430f0212, 0x100f0312, 0x0a0f0202, 0xfa080202, 0x470f0212, + 0x470f0202, 0x260f0412, 0x230f0212, 0x230f0202, 0x240f0412, 0x270f0212, 0x260f1012, 0x270f1012, + 0x14100f12, 0x14101312, 0x11100212, 0x0a100e12, 0x19100212, 0x20100212, 0x26100212, 0x26101312, + 0x2c100212, 0x34100212, 0x44100212, 0x5d100212, 0x2e100e12, 0x22100f12, 0x63101512, 0x81100212, + 0x02100212, 0x06100212, 0x08100212, 0x0a100212, 0x0f100212, 0x14100212, 0x1b100212, 0x1e100212, + 0x22100212, 0x22101512, 0x2e100212, 0x32100212, 0x38100212, 0x3a100212, 0x48100212, 0x4f100212, + 0x51100212, 0x53100212, 0x57100212, 0x63100212, 0x6c100212, 0x6f100212, 0x75100212, 0x78100212, + 0x84100212, 0x87100212, 0x8a100212, 0x8d100212, 0x96100212, 0x9c100212, 0xa2100212, 0xa5100212, + 0x02100202, 0x06100202, 0x08100202, 0x0a100202, 0x0f100202, 0x14100202, 0x1b100202, 0x1e100202, + 0x22100202, 0x22101502, 0x2e100202, 0x32100202, 0x38100202, 0x3a100202, 0x48100202, 0x4f100202, + 0x51100202, 0x53100202, 0x57100202, 0x63100202, 0x6c100202, 0x6f100202, 0x75100202, 0x78100202, + 0x84100202, 0x87100202, 0x8a100202, 0x8d100202, 0x96100202, 0x9c100202, 0xa2100202, 0xa5100202, + 0x14100f02, 0x14101302, 0x11100202, 0x0a100e02, 0x19100202, 0x20100202, 0x26100202, 0x26101302, + 0x2c100202, 0x34100202, 0x44100202, 0x5d100202, 0x2e100e02, 0x22100f02, 0x63101502, 0x81100202, + 0xab100212, 0xab100202, 0xae100212, 0xae100202, 0xb1100212, 0xb1100202, 0xb4100212, 0xb4100202, + 0xb7100212, 0xb7100202, 0xba100212, 0xba100202, 0xbd100212, 0xbd100202, 0xc0100212, 0xc0100202, + 0xc3100212, 0xc3100202, 0xc6100212, 0xc6100202, 0xc9100212, 0xc9100202, 0xc9104412, 0xc9104402, + 0xcf100212, 0xcf100202, 0xd2100212, 0xd2100202, 0xd5100212, 0xd5100202, 0xd8100212, 0xd8100202, + 0xdb100212, 0xdb100202, 0x6e0d0202, 0x00019400, 0x00019500, 0x00019600, 0x00019700, 0x00019800, + 0x7d0d0202, 0x960d0202, 0x24100212, 0x24100202, 0x99100212, 0x99100202, 0xde100212, 0xde100202, + 0x0c100212, 0x0c100202, 0x0a101a12, 0x0a101a02, 0x0d100212, 0x0d100202, 0x1d100212, 0x1d100202, + 0x1e101a12, 0x1e101a02, 0x30100212, 0x30100202, 0x2e100912, 0x2e100902, 0x2e100412, 0x2e100402, + 0x2e100a12, 0x2e100a02, 0x3c100212, 0x3c100202, 0x3e100212, 0x3e100202, 0x4f100512, 0x4f100502, + 0x4c100512, 0x4c100502, 0x53101a12, 0x53101a02, 0x5b100712, 0x5b100702, 0x66100212, 0x66100202, + 0x69100212, 0x69100202, 0x72100212, 0x72100202, 0x75100412, 0x75100402, 0x78100712, 0x78100702, + 0x78100912, 0x78100902, 0x40100212, 0x40100202, 0x15100512, 0x15100502, 0x16101712, 0x16101702, + 0x4d100312, 0x1b101512, 0x1b101502, 0x2e100512, 0x2e100502, 0xe1100212, 0xe1100202, 0x42100212, + 0x42100202, 0xe4100212, 0xe4100202, 0x7e100212, 0x7e100202, 0xe7100212, 0xe7100202, 0x4d100302, + 0x02101512, 0x02101502, 0x02101312, 0x02101302, 0xea100212, 0xea100202, 0x14101512, 0x14101502, + 0x17100212, 0x17100202, 0x17101312, 0x17101302, 0x1b101312, 0x1b101302, 0x1e101312, 0x1e101302, + 0xed100212, 0xed100202, 0x22101712, 0x22101702, 0x22101312, 0x22101302, 0x48101312, 0x48101302, + 0x4c100212, 0x4c100202, 0x4c101312, 0x4c101302, 0x9c101312, 0x9c101302, 0x63101712, 0x63101702, + 0x63101312, 0x63101302, 0x63101d12, 0x63101d02, 0x78101312, 0x78101302, 0x0e100212, 0x0e100202, + 0x8d101312, 0x8d101302, 0x0a103d12, 0x0a103d02, 0x6f101412, 0x6f101402, 0x6f102712, 0x6f102702, + 0x10100212, 0x10100202, 0x12100212, 0x12100202, 0x1f100212, 0x1f100202, 0xf0100212, 0xf0100202, + 0x36100212, 0x36100202, 0x46100212, 0x46100202, 0x55100212, 0x55100202, 0x59100212, 0x59100202, + 0x1e105112, 0x1e105102, 0x32101412, 0x32101402, 0x37100212, 0x37100202, 0xdf100212, 0xdf100202, + 0xa6100212, 0xa6100202, 0xf8100212, 0xf8100202, 0x4c100612, 0x4c100602, 0xf7100212, 0xf7100202, + 0x33100212, 0x33100202, 0x43100212, 0x43100202, 0x00000000, 0x00000000, 0x40100312, 0x40100302, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x03110212, 0x04110212, 0x05110212, 0x06110212, 0x07110212, 0x08110212, 0x09110212, + 0x0a110212, 0x0b110212, 0x0c110212, 0x0d110212, 0x0e110212, 0x0f110212, 0x10110212, 0x11110212, + 0x12110212, 0x13110212, 0x14110212, 0x15110212, 0x16110212, 0x17110212, 0x18110212, 0x19110212, + 0x1a110212, 0x1b110212, 0x1c110212, 0x1d110212, 0x1e110212, 0x1f110212, 0x20110212, 0x21110212, + 0x22110212, 0x23110212, 0x24110212, 0x25110212, 0x26110212, 0x27110212, 0x28110212, 0x00000000, + 0x00000000, 0x00019800, 0x00019900, 0x65070202, 0x66070202, 0x67070202, 0x68070202, 0x69070202, + 0x00000000, 0x03110202, 0x04110202, 0x05110202, 0x06110202, 0x07110202, 0x08110202, 0x09110202, + 0x0a110202, 0x0b110202, 0x0c110202, 0x0d110202, 0x0e110202, 0x0f110202, 0x10110202, 0x11110202, + 0x12110202, 0x13110202, 0x14110202, 0x15110202, 0x16110202, 0x17110202, 0x18110202, 0x19110202, + 0x1a110202, 0x1b110202, 0x1c110202, 0x1d110202, 0x1e110202, 0x1f110202, 0x20110202, 0x21110202, + 0x22110202, 0x23110202, 0x24110202, 0x25110202, 0x26110202, 0x27110202, 0x28110202, 0x00000000, + 0x00000000, 0x6a070202, 0x84061502, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00010400, 0x00010500, 0x00010600, 0x00010700, 0x00010800, 0x00010900, 0x00010a00, + 0x00010b00, 0x00010c00, 0x00010d00, 0x00010e00, 0x00010f00, 0x00011000, 0x00011100, 0x00011200, + 0x00011300, 0x00011500, 0x00010300, 0x00011600, 0x00011700, 0x00011800, 0x00011900, 0x00011a00, + 0x00011b00, 0x00011c00, 0x00011d00, 0x00011e00, 0x00011f00, 0x00012000, 0x00012100, 0x00012200, + 0x00012300, 0x00012400, 0x00012500, 0x00012600, 0x00012700, 0x00012800, 0x00012900, 0x00012a00, + 0x00012b00, 0x00012d00, 0x00012d00, 0x00012e00, 0x00012f00, 0x00013000, 0x02076402, 0x00013100, + 0x00013200, 0x00013300, 0x00013400, 0x6d070202, 0x00012100, 0x00013500, 0x45070202, 0x00012b00, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x02280202, 0x03280202, 0x04280202, 0x05280202, 0x06280202, 0x07280202, 0x08280202, 0x09280202, + 0x0a280202, 0x0b280202, 0x0d280202, 0x0d280212, 0x0e280202, 0x0f280202, 0x0f280212, 0x11280202, + 0x11280212, 0x13280202, 0x14280202, 0x15280202, 0x15280212, 0x17280202, 0x17280212, 0x19280202, + 0x1a280202, 0x1b280202, 0x1c280202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x6e070202, 0x6f070202, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x910b0202, 0x980b0202, 0x00016600, 0x990b0202, 0x00000000, 0x00000000, 0xf90b0202, 0xfa0b0202, + 0xfb0b0202, 0xfc0b0202, 0xfd0b0202, 0xb1070202, 0x70070202, 0x970b0202, 0x8d0b0202, 0x950b0202, + 0x0001c700, 0x0001bf00, 0x0001c000, 0x0001c100, 0x0001c200, 0x0001ca00, 0x0001ec00, 0x0001ed00, + 0x0001ee00, 0x0001ef00, 0x0001f000, 0x71070202, 0x00000000, 0x00000000, 0x1f070202, 0x72070202, + 0xdb290202, 0x02290202, 0x0b29d902, 0x0b29d702, 0xb929d702, 0x0b29d602, 0xd729d702, 0x0b290202, + 0x0e290202, 0x1d290202, 0x20290202, 0x2f290202, 0x32290202, 0x41290202, 0x44290202, 0x47290202, + 0x53290202, 0x59290202, 0x5f290202, 0x68290202, 0x6b290202, 0x6e290202, 0x71290202, 0x74290202, + 0x77290202, 0x7a290202, 0x7d290202, 0x95291f22, 0x95294722, 0xd7295a02, 0xd7296402, 0xd7296e02, + 0x00000000, 0x80291402, 0x8c291402, 0x8f290202, 0xa7290202, 0xaa290202, 0xad291402, 0xb6290202, + 0xb9290202, 0xd4290205, 0xd7290202, 0x0001dd00, 0x0001de00, 0x0001df00, 0x0001e000, 0x0001e100, + 0x0001e200, 0x0001e400, 0x0001e300, 0x0001d800, 0x0001d600, 0x0001d400, 0x0001c500, 0x0001c600, + 0x0001dc00, 0x0001e600, 0x0001e700, 0x0001e800, 0x0001e900, 0x0001ea00, 0x0001eb00, 0x0001d500, + 0x030d0402, 0x1a0d0402, 0x1c0d0402, 0x1e0d0402, 0x200d0402, 0x220d0402, 0x240d0402, 0x260d0402, + 0x280d0402, 0x2a0d0402, 0x73070202, 0x74070202, 0x75070202, 0x930b0202, 0x14290202, 0x8c290202, + 0x0001e500, 0x05291502, 0x0529dc04, 0x0529c804, 0x08290202, 0x00000000, 0x00000000, 0xc229d702, + 0x00000000, 0x2c290202, 0x23290202, 0x11290202, 0x29291402, 0x29292802, 0x1a290202, 0x26290202, + 0x17290202, 0x41291402, 0x41292802, 0x35290202, 0x38290202, 0x41293c02, 0x3b290202, 0x3e290202, + 0x4a290202, 0x4a291402, 0x4a292802, 0x47292802, 0x56290202, 0x4d290202, 0x50290202, 0x50291402, + 0x50292802, 0x5c290202, 0x59292802, 0x5c291402, 0x59295002, 0x59291402, 0x59296402, 0x59297802, + 0x65290202, 0x62291402, 0x68292802, 0x68291402, 0x68293c02, 0x6e291402, 0x6e292802, 0x74291402, + 0x7a291402, 0x80290202, 0x80292802, 0x80293c02, 0x83290202, 0x86290202, 0x89290202, 0x8c292802, + 0x8c293c02, 0x95290222, 0x9829022a, 0x8f291402, 0x8f293c02, 0x92290202, 0x8f292802, 0x9b290202, + 0x9b291402, 0x9e290202, 0xa4290202, 0xa1290202, 0xa4291402, 0xa7291402, 0xa7293c02, 0xa7295002, + 0xa7292802, 0xb3291402, 0xad290202, 0xb0290202, 0xad292802, 0xb3292802, 0xb6291902, 0x3b291402, + 0xda29d702, 0xb6291202, 0xb629e702, 0x1d291402, 0xb9290b02, 0xbf290202, 0xbc290202, 0xc2290202, + 0xc5290202, 0xc8290202, 0xb9291902, 0xcb290202, 0xd7295002, 0xd1290202, 0xd7290b02, 0xb9291202, + 0xce290202, 0xd7291202, 0xd7291902, 0xd729ee02, 0x76070202, 0xda290202, 0x00000000, 0x00000000, + 0x0001d300, 0x0001cb00, 0x0001cf00, 0x0001c400, 0x0001d000, 0x890b0202, 0x940b0202, 0x030d040c, + 0x030d040c, 0x0001ce00, 0x0001db00, 0x0001d200, 0x0001cd00, 0x0001c900, 0x0001cc00, 0x0001d700, + 0x0001d900, 0x920b0202, 0x0001d100, 0x0001c800, 0x00012c00, 0x0001da00, 0x47291402, 0x59293c02, + 0x030d0502, 0x1a0d0502, 0x1c0d0502, 0x1e0d0502, 0x200d0502, 0x220d0502, 0x240d0502, 0x260d0502, + 0x280d0502, 0x2a0d0502, 0x6b291402, 0x71291402, 0x7d291402, 0x870b0202, 0x900b0202, 0xb6290b02, + 0xe2070202, 0xe3070202, 0xe4070202, 0xe5070202, 0xe6070202, 0xe7070202, 0xe8070202, 0xe9070202, + 0xea070202, 0xeb070202, 0xec070202, 0xed070202, 0xee070202, 0xef070202, 0x00000000, 0xf0070202, + 0x0b2a0202, 0x00019a00, 0x0f2a0202, 0x132a0202, 0x152a0202, 0x172a0202, 0x192a0202, 0x1b2a0202, + 0x1f2a0202, 0x232a0202, 0x272a0202, 0x2b2a0202, 0x2d2a0202, 0x2f2a0202, 0x312a0202, 0x332a0202, + 0x372a0202, 0x3b2a0202, 0x402a0202, 0x442a0202, 0x462a0202, 0x482a0202, 0x4c2a0202, 0x4e2a0202, + 0x502a0202, 0x542a0202, 0x582a0202, 0x5c2a0202, 0x602a0202, 0x102a0202, 0x142a0202, 0x1a2a0202, + 0x00019f00, 0x0001a000, 0x00019400, 0x0001a100, 0x0001a200, 0x00019500, 0x0001a300, 0x0001a400, + 0x00019600, 0x00019700, 0x0001a500, 0x0001a600, 0x00019800, 0x0001a700, 0x0001a800, 0x00019900, + 0x00018d00, 0x00018e00, 0x00018f00, 0x00019b00, 0x00019c00, 0x00019d00, 0x00019e00, 0x00019000, + 0x00019100, 0x0001a900, 0x0001aa00, 0x00000000, 0x00000000, 0x242a0202, 0x342a0202, 0x4d2a0202, + 0x0e291502, 0x0e291f02, 0x0e292902, 0x0e293302, 0x0e293d02, 0x0e294702, 0x0e295102, 0x41293202, + 0x41294602, 0x47293c02, 0x47295002, 0x59298c02, 0x68295002, 0x7a292802, 0x7a293c02, 0x7a295002, + 0x80295002, 0x80296402, 0x95291522, 0x95292922, 0x95293d22, 0xaa291502, 0xaa292902, 0xad293c02, + 0xad295002, 0xad296402, 0xa7296402, 0x5929a002, 0x5929b402, 0x68296402, 0x41295002, 0x41295a02, + 0x68296e02, 0x5929be02, 0x41296402, 0x0b29f202, 0x0b29f302, 0xd7297802, 0xd7298202, 0xd7298c02, + 0xb929f202, 0xb929f302, 0xd729f202, 0xd729f302, 0x4129f402, 0x68297802, 0x68298202, 0x8f295002, + 0x6e2a0202, 0x742a0202, 0x762a0202, 0x7a2a0202, 0x7e2a0202, 0x802a0202, 0x822a0202, 0x842a0202, + 0x8a2a0202, 0x8e2a0202, 0x902a0202, 0x922a0202, 0x962a0202, 0x9e2a0202, 0xa02a0202, 0xa42a0202, + 0xa62a0202, 0xae2a0202, 0xb02a0202, 0xb22a0202, 0xb42a0202, 0xb62a0202, 0xb82a0202, 0xba2a0202, + 0x982a0202, 0x702a0202, 0x722a0202, 0x942a0202, 0x7c2a0202, 0xa82a0202, 0xaa2a0202, 0xac2a0202, + 0x9a2a0202, 0x9c2a0202, 0x862a0202, 0x882a0202, 0xa22a0202, 0x8c2a0202, 0x0001ac00, 0x0001ad00, + 0x0001ae00, 0x0001af00, 0x0001b000, 0x0001b100, 0x0001b200, 0x0001b300, 0x0001b400, 0x0001b500, + 0x0001b600, 0x782a0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x030d1b02, 0x1a0d1b02, 0x1c0d1b02, 0x1e0d1b02, 0x200d1b02, 0x220d1b02, 0x240d1b02, 0x260d1b02, + 0x280d1b02, 0x2a0d1b02, 0x03540202, 0x05540202, 0x07540202, 0x09540202, 0x0b540202, 0x0d540202, + 0x0f540202, 0x11540202, 0x13540202, 0x15540202, 0x17540202, 0x19540202, 0x1b540202, 0x1d540202, + 0x1f540202, 0x21540202, 0x23540202, 0x25540202, 0x27540202, 0x29540202, 0x2b540202, 0x2d540202, + 0x2f540202, 0x31540202, 0x33540202, 0x35540202, 0x37540202, 0x39540202, 0x3b540202, 0x3d540202, + 0x3f540202, 0x41540202, 0x43540202, 0x00010a00, 0x00010b00, 0x00010c00, 0x00010d00, 0x00010e00, + 0x00010f00, 0x00011000, 0x00011100, 0x00011300, 0x81060202, 0x81061402, 0xf3070202, 0xf4070202, + 0x2f070502, 0x1c070a02, 0xf5070202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x02660202, 0x03660202, 0x04660202, 0x05660202, 0x06660202, 0x07660202, 0x08660202, 0x09660202, + 0x0a660202, 0x0b660202, 0x0c660202, 0x0d660202, 0x0e660202, 0x0f660202, 0x10660202, 0x11660202, + 0x12660202, 0x13660202, 0x14660202, 0x15660202, 0x16660202, 0x17660202, 0x18660202, 0x19660202, + 0x00017100, 0x00017200, 0x1a660202, 0x1b660202, 0x00015500, 0x00015600, 0x00015700, 0x00015800, + 0x00015900, 0x00016400, 0x00016500, 0x00016700, 0x00016800, 0x00016900, 0x00016a00, 0x00016b00, + 0x00016c00, 0x00016d00, 0x00016e00, 0x00016f00, 0x00017000, 0x00017300, 0x00000000, 0x00000000, + 0xf5070302, 0xf5070402, 0xf5070502, 0xf5070602, 0xf5070702, 0xf5070802, 0xf5070902, 0xf5070a02, + 0xf5070b02, 0xf5070c02, 0xf5070d02, 0xf5070e02, 0xf5070f02, 0xf5071002, 0xf5071102, 0x00000000, + 0x026c0202, 0x036c0202, 0x046c0202, 0x056c0202, 0x066c0202, 0x076c0202, 0x086c0202, 0x096c0202, + 0x0a6c0202, 0x0b6c0202, 0x0c6c0202, 0x0d6c0202, 0x0e6c0202, 0x0f6c0202, 0x106c0202, 0x116c0202, + 0x126c0202, 0x136c0202, 0x146c0202, 0x156c0202, 0x166c0202, 0x176c0202, 0x186c0202, 0x196c0202, + 0x1a6c0202, 0x00019e00, 0x00019e00, 0x00019e00, 0x00000000, 0x00000000, 0xf5071202, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x04320202, 0x06320202, 0x08320202, 0x0d320202, 0x0b320202, 0x0f320202, 0x13320202, + 0x17320202, 0x1b320202, 0x1f320202, 0x23320202, 0x2b320202, 0x33320202, 0x37320202, 0x3b320202, + 0x3f320202, 0x43320202, 0x47320202, 0x4b320202, 0x4f320202, 0x53320202, 0x57320202, 0x5b320202, + 0x5f320202, 0x63320202, 0x67320202, 0x6b320202, 0x6f320202, 0x73320202, 0x77320202, 0x7b320202, + 0x7f320202, 0x83320202, 0x87320202, 0x8b320202, 0x8f320202, 0x93320202, 0x97320202, 0x9b320202, + 0x9f320202, 0x9f320802, 0xa3320202, 0xa7320202, 0xab320202, 0xaf320202, 0xb3320202, 0xb7320202, + 0xbb320202, 0xbb320802, 0xbf320202, 0xc3320202, 0xc3320802, 0xc7320202, 0xcb320202, 0xcf320202, + 0xd3320202, 0xd7320202, 0xda320302, 0xda320402, 0x00010600, 0x0a320202, 0xda320202, 0xdc320202, + 0xde320202, 0xe0320202, 0xe2320202, 0xe4320202, 0xe6320202, 0xec320202, 0xee320202, 0xf0320202, + 0xf2320202, 0xf4320202, 0xf6320202, 0xf8320202, 0xfa320202, 0xfc320202, 0xf1320202, 0xda320502, + 0xdd070202, 0x00010a00, 0x00010c00, 0x00010e00, 0x00011000, 0xed320202, 0xda320602, 0xda320702, + 0x53320802, 0x57320802, 0x5b320802, 0x6f320802, 0x83320802, 0x87320802, 0xa7320802, 0xb7320802, + 0x27320202, 0x2f320202, 0xe8320202, 0xea320202, 0xdf070202, 0xe0070202, 0x030d0602, 0x1a0d0602, + 0x1c0d0602, 0x1e0d0602, 0x200d0602, 0x220d0602, 0x240d0602, 0x260d0602, 0x280d0602, 0x2a0d0602, + 0xe1070202, 0x00010700, 0x0c320202, 0x0f320302, 0x0f320402, 0x0f320502, 0x0f320602, 0x0f320702, + 0x00000000, 0x70320202, 0xb8320202, 0x61320202, 0x71320202, 0x09320202, 0x9d320202, 0xb1320202, + 0x00000000, 0x02330202, 0x03330202, 0x04330202, 0x00000000, 0x06330202, 0x07330202, 0x08330202, + 0x09330202, 0x0a330202, 0x0b330202, 0x0c330202, 0x0e330202, 0x00000000, 0x00000000, 0x10330202, + 0x11330202, 0x00000000, 0x00000000, 0x12330202, 0x13330202, 0x14330202, 0x15330202, 0x16330202, + 0x17330202, 0x18330202, 0x19330202, 0x1a330202, 0x1b330202, 0x1c330202, 0x1d330202, 0x1e330202, + 0x1f330202, 0x20330202, 0x21330202, 0x22330202, 0x23330202, 0x24330202, 0x25330202, 0x26330202, + 0x27330202, 0x00000000, 0x28330202, 0x29330202, 0x2a330202, 0x2b330202, 0x2c330202, 0x2d330202, + 0x2f330602, 0x00000000, 0x31330202, 0x00000000, 0x00000000, 0x00000000, 0x33330202, 0x34330202, + 0x35330202, 0x36330202, 0x00000000, 0x00000000, 0x00010400, 0x05330202, 0x3d330202, 0x3e330202, + 0x3f330202, 0x40330502, 0x41330602, 0x42330702, 0x43330802, 0x00000000, 0x00000000, 0x46330202, + 0x47330202, 0x00000000, 0x00000000, 0x48330202, 0x49330202, 0x4a330202, 0x23330b02, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x4b330202, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x20330602, 0x21330602, 0x00000000, 0x2e330602, + 0x0d330202, 0x0f330202, 0x44330a02, 0x45330b02, 0x00000000, 0x00000000, 0x030d0702, 0x1a0d0702, + 0x1c0d0702, 0x1e0d0702, 0x200d0702, 0x220d0702, 0x240d0702, 0x260d0702, 0x280d0702, 0x2a0d0702, + 0x30330202, 0x32330202, 0xac070202, 0xad070202, 0xa10d5a02, 0xa20d5c02, 0xa30d5e02, 0xa40d6002, + 0xa00d5802, 0xa50d6202, 0x8b070c02, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00010a00, 0x00010a00, 0x02340202, 0x00000000, 0x18340202, 0x1c340202, 0x2c340202, + 0x30340202, 0x0c340202, 0x10340202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x34340202, + 0x20340202, 0x00000000, 0x00000000, 0x14340202, 0x24340202, 0x40340202, 0x44340202, 0x48340202, + 0x4c340202, 0x50340202, 0x54340202, 0x58340202, 0x5c340202, 0x60340202, 0x64340202, 0x68340202, + 0x6c340202, 0x70340202, 0x74340202, 0x78340202, 0x7c340202, 0x80340202, 0x84340202, 0x88340202, + 0x8c340202, 0x00000000, 0x90340202, 0x94340202, 0x98340202, 0x9c340202, 0xa0340202, 0xa4340202, + 0xa8340202, 0x00000000, 0xac340202, 0xac340602, 0x00000000, 0xb0340202, 0x38340602, 0x00000000, + 0x38340202, 0x3c340202, 0x00000000, 0x00000000, 0x00010400, 0x00000000, 0xc0340202, 0xc4340202, + 0xc8340202, 0xcc340202, 0xd0340202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xd4340202, + 0xd8340202, 0x00000000, 0x00000000, 0xdc340202, 0xe0340202, 0xe1340202, 0x00000000, 0x00000000, + 0x00000000, 0x3d340202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x44340602, 0x48340602, 0x5c340602, 0xb4340202, 0x00000000, 0x94340602, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x030d0802, 0x1a0d0802, + 0x1c0d0802, 0x1e0d0802, 0x200d0802, 0x220d0802, 0x240d0802, 0x260d0802, 0x280d0802, 0x2a0d0802, + 0x00010e00, 0x00010600, 0x28340202, 0x08340202, 0x04340202, 0xa5340202, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x03350202, 0x04350202, 0x05350202, 0x00000000, 0x07350202, 0x08350202, 0x09350202, + 0x0a350202, 0x0b350202, 0x0c350202, 0x0d350202, 0x0f350202, 0x11350202, 0x00000000, 0x12350202, + 0x13350202, 0x14350202, 0x00000000, 0x15350202, 0x16350202, 0x28350202, 0x29350202, 0x2a350202, + 0x2b350202, 0x2c350202, 0x2d350202, 0x2e350202, 0x2f350202, 0x30350202, 0x31350202, 0x32350202, + 0x33350202, 0x34350202, 0x35350202, 0x36350202, 0x37350202, 0x38350202, 0x39350202, 0x3a350202, + 0x3b350202, 0x00000000, 0x3c350202, 0x3d350202, 0x3e350202, 0x3f350202, 0x40350202, 0x41350202, + 0x42350202, 0x00000000, 0x43350202, 0x49350202, 0x00000000, 0x44350202, 0x45350202, 0x46350202, + 0x47350202, 0x48350202, 0x00000000, 0x00000000, 0x00010b00, 0x06350202, 0x5a350202, 0x5b350202, + 0x5c350202, 0x5d350202, 0x5e350202, 0x5f350202, 0x60350502, 0x63350202, 0x00000000, 0x64350202, + 0x65350202, 0x66350202, 0x00000000, 0x67350202, 0x68350202, 0x69350202, 0x00000000, 0x00000000, + 0x02350202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x0e350502, 0x10350502, 0x61350202, 0x62350502, 0x00000000, 0x00000000, 0x030d0902, 0x1a0d0902, + 0x1c0d0902, 0x1e0d0902, 0x200d0902, 0x220d0902, 0x240d0902, 0x260d0902, 0x280d0902, 0x2a0d0902, + 0x00000000, 0xae070202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x02360202, 0x06360202, 0x0a360202, 0x00000000, 0x14360202, 0x16360202, 0x18360202, + 0x1a360202, 0x1c360202, 0x1e360202, 0x20360202, 0x24360202, 0x00000000, 0x00000000, 0x28360202, + 0x2a360202, 0x00000000, 0x00000000, 0x2c360202, 0x2e360202, 0x32360202, 0x34360202, 0x36360202, + 0x38360202, 0x3a360202, 0x3c360202, 0x3e360202, 0x40360202, 0x42360202, 0x44360202, 0x46360202, + 0x48360202, 0x4c360202, 0x50360202, 0x52360202, 0x54360202, 0x56360202, 0x58360202, 0x5a360202, + 0x5c360202, 0x00000000, 0x5e360202, 0x60360202, 0x62360202, 0x64360202, 0x66360202, 0x68360202, + 0x6c360202, 0x00000000, 0x6e360202, 0x70360202, 0x00000000, 0x74360202, 0x76360202, 0x78360202, + 0x7a360202, 0x7c360202, 0x00000000, 0x00000000, 0x00010400, 0x0b360202, 0x8c360202, 0x8e360202, + 0x90360202, 0x92360202, 0x94360202, 0x96360202, 0x97360202, 0x00000000, 0x00000000, 0x9a360202, + 0x9b360202, 0x00000000, 0x00000000, 0x9d360202, 0x9e360202, 0xa0360202, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x9c360402, 0x9f360402, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x4c360602, 0x50360602, 0x00000000, 0x6a360602, + 0x22360202, 0x26360202, 0x98360202, 0x99360202, 0x00000000, 0x00000000, 0x030d0a02, 0x1a0d0a02, + 0x1c0d0a02, 0x1e0d0a02, 0x200d0a02, 0x220d0a02, 0x240d0a02, 0x260d0a02, 0x280d0a02, 0x2a0d0a02, + 0x00010300, 0x72360202, 0x0d0d0e03, 0x110de103, 0x150d0e03, 0x030dec02, 0x090d0203, 0x0b0d0302, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x0a370202, 0x0c370202, 0x00000000, 0x0e370202, 0x10370202, 0x12370202, + 0x14370202, 0x16370202, 0x18370202, 0x00000000, 0x00000000, 0x00000000, 0x1a370202, 0x1c370202, + 0x1e370202, 0x00000000, 0x20370202, 0x22370202, 0x24370202, 0x28370202, 0x00000000, 0x00000000, + 0x00000000, 0x2c370202, 0x30370202, 0x00000000, 0x70370202, 0x00000000, 0x34370202, 0x38370202, + 0x00000000, 0x00000000, 0x00000000, 0x3c370202, 0x40370202, 0x00000000, 0x00000000, 0x00000000, + 0x44370202, 0x6c370202, 0x48370202, 0x00000000, 0x00000000, 0x00000000, 0x4c370202, 0x50370202, + 0x54370202, 0x68370202, 0x58370202, 0x64370202, 0x60370202, 0x5c370202, 0x76370202, 0x78370202, + 0x74370202, 0x7e370202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x82370202, 0x84370202, + 0x86370202, 0x88370202, 0x8a370202, 0x00000000, 0x00000000, 0x00000000, 0x8c370202, 0x8e370202, + 0x90370202, 0x00000000, 0x92370202, 0x94370202, 0x96370202, 0x97370202, 0x00000000, 0x00000000, + 0x02370202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x05370202, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x030d1902, 0x1a0d0b02, + 0x1c0d0b02, 0x1e0d0b02, 0x200d0b02, 0x220d0b02, 0x240d0b02, 0x260d0b02, 0x280d0b02, 0x2a0d0b02, + 0x2c0d0b02, 0x5e0d1602, 0x5f0d0b02, 0x430c0202, 0x440c0202, 0x450c0202, 0x460c0202, 0x470c0202, + 0x480c0202, 0xaf070202, 0x490c0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x04380202, 0x07380202, 0x0a380202, 0x00000000, 0x0d380202, 0x10380202, 0x13380202, + 0x16380202, 0x19380202, 0x1c380202, 0x1f380202, 0x25380202, 0x00000000, 0x2b380202, 0x2e380202, + 0x31380202, 0x00000000, 0x34380202, 0x37380202, 0x3a380202, 0x3d380202, 0x40380202, 0x43380202, + 0x46380202, 0x49380202, 0x4c380202, 0x4f380202, 0x52380202, 0x55380202, 0x58380202, 0x5b380202, + 0x5e380202, 0x61380202, 0x64380202, 0x67380202, 0x6a380202, 0x6d380202, 0x70380202, 0x73380202, + 0x76380202, 0x00000000, 0x79380202, 0x7c380202, 0x7f380202, 0x82380202, 0x85380202, 0x88380202, + 0x8b380202, 0x8e380202, 0x91380202, 0x94380202, 0x00000000, 0x97380202, 0x9a380202, 0x9d380202, + 0xa0380202, 0xa3380202, 0x00000000, 0x00000000, 0x00000000, 0x0b380202, 0xa6380202, 0xa9380202, + 0xac380202, 0xaf380202, 0xb2380202, 0xb5380202, 0xb8380202, 0x00000000, 0xbb380202, 0xbe380202, + 0xc1380202, 0x00000000, 0xc4380202, 0xc7380202, 0xca380202, 0xcd380202, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00010d00, 0x00010e00, 0x00000000, + 0x4d380202, 0x53380202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x22380202, 0x28380202, 0xb9380202, 0xba380202, 0x00000000, 0x00000000, 0x030d0c02, 0x1a0d0c02, + 0x1c0d0c02, 0x1e0d0c02, 0x200d0c02, 0x220d0c02, 0x240d0c02, 0x260d0c02, 0x280d0c02, 0x2a0d0c02, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x030d2502, 0x1a0d2502, 0x1c0d2502, 0x1e0d2502, 0x1a0d2602, 0x1c0d2602, 0x1e0d2602, 0xfc0c0202, + 0x00000000, 0x00000000, 0x04390202, 0x07390202, 0x00000000, 0x0a390202, 0x0d390202, 0x10390202, + 0x13390202, 0x16390202, 0x19390202, 0x1a390202, 0x1c390202, 0x00000000, 0x22390202, 0x25390202, + 0x28390202, 0x00000000, 0x2b390202, 0x2e390202, 0x31390202, 0x34390202, 0x37390202, 0x3a390202, + 0x3d390202, 0x40390202, 0x43390202, 0x46390202, 0x49390202, 0x4c390202, 0x4f390202, 0x52390202, + 0x55390202, 0x58390202, 0x5b390202, 0x5e390202, 0x61390202, 0x64390202, 0x67390202, 0x6a390202, + 0x6d390202, 0x00000000, 0x70390202, 0x73390202, 0x76390202, 0x79390202, 0x7c390202, 0x7f390202, + 0x82390202, 0x97390202, 0x85390202, 0x9d390202, 0x00000000, 0x8b390202, 0x8e390202, 0x91390202, + 0x94390202, 0x9a390202, 0x00000000, 0x00000000, 0x00010400, 0x08390202, 0xa3390202, 0xa6390202, + 0xa9390202, 0xac390202, 0xaf390202, 0xb2390202, 0xb5390202, 0x00000000, 0xb8390202, 0xbb390202, + 0xbe390202, 0x00000000, 0xc1390202, 0xc4390202, 0xc7390202, 0xc8390202, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00010400, 0x00010500, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xa0390202, 0x00000000, + 0x1b390202, 0x1d390202, 0xb6390202, 0xb7390202, 0x00000000, 0x00000000, 0x030d0d02, 0x1a0d0d02, + 0x1c0d0d02, 0x1e0d0d02, 0x200d0d02, 0x220d0d02, 0x240d0d02, 0x260d0d02, 0x280d0d02, 0x2a0d0d02, + 0x00000000, 0xf1070202, 0xf2070202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x023a0202, 0x033a0202, 0x00000000, 0x053a0202, 0x093a0202, 0x0d3a0202, + 0x113a0202, 0x153a0202, 0x193a0202, 0x1a3a0202, 0x1c3a0202, 0x00000000, 0x253a0202, 0x293a0202, + 0x2d3a0202, 0x00000000, 0x313a0202, 0x353a0202, 0x393a0202, 0x3d3a0202, 0x413a0202, 0x453a0202, + 0x493a0202, 0x4d3a0202, 0x513a0202, 0x553a0202, 0x593a0202, 0x5d3a0202, 0x613a0202, 0x653a0202, + 0x693a0202, 0x6d3a0202, 0x713a0202, 0x753a0202, 0x793a0202, 0x7d3a0202, 0x813a0202, 0x853a0202, + 0x893a0202, 0x873a0202, 0x8d3a0202, 0x913a0202, 0x953a0202, 0x993a0202, 0x9d3a0202, 0xa13a0202, + 0xa53a0202, 0xa93a0202, 0xad3a0202, 0xb13a0202, 0xb53a0202, 0xb93a0202, 0xbd3a0202, 0xc13a0202, + 0xc53a0202, 0xc93a0202, 0xf63a0202, 0x00000000, 0x00000000, 0x043a0202, 0xcd3a0202, 0xd13a0202, + 0xd53a0202, 0xd93a0202, 0xdd3a0202, 0xdf3a0202, 0xe03a0202, 0x00000000, 0xe33a0202, 0xe43a0202, + 0xe53a0202, 0x00000000, 0xeb3a0202, 0xee3a0202, 0xf13a0202, 0xf23a0202, 0xf53a0202, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x013a0802, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x1b3a0202, 0x1d3a0202, 0xe13a0202, 0xe23a0202, 0x00000000, 0x00000000, 0x030d0e02, 0x1a0d0e02, + 0x1c0d0e02, 0x1e0d0e02, 0x200d0e02, 0x220d0e02, 0x240d0e02, 0x260d0e02, 0x280d0e02, 0x2a0d0e02, + 0x2c0d1502, 0x5e0d1502, 0x5f0d0202, 0x0d0d0e02, 0x110d0e02, 0x150d0e02, 0x00000000, 0x00000000, + 0x00000000, 0x5a0c0202, 0x723a0202, 0x863a0202, 0xa63a0202, 0xaa3a0202, 0xae3a0202, 0x3a3a0202, + 0x00000000, 0x00000000, 0x023b0202, 0x033b0202, 0x00000000, 0x053b0202, 0x073b0202, 0x093b0202, + 0x0b3b0202, 0x0d3b0202, 0x0f3b0202, 0x113b0202, 0x133b0202, 0x153b0202, 0x173b0202, 0x193b0202, + 0x1b3b0202, 0x1d3b0202, 0x1f3b0202, 0x213b0202, 0x233b0202, 0x253b0202, 0x273b0202, 0x00000000, + 0x00000000, 0x00000000, 0x293b0202, 0x2c3b0202, 0x2f3b0202, 0x323b0202, 0x353b0202, 0x383b0202, + 0x3b3b0202, 0x3e3b0202, 0x403b0202, 0x443b0202, 0x483b0202, 0x4b3b0202, 0x4e3b0202, 0x513b0202, + 0x543b0202, 0x583b0202, 0x5b3b0202, 0x5e3b0202, 0x613b0202, 0x643b0202, 0x673b0202, 0x6a3b0202, + 0x6e3b0202, 0x713b0202, 0x00000000, 0x743b0202, 0x773b0202, 0x7a3b0202, 0x7d3b0202, 0x803b0202, + 0x833b0202, 0x863b0202, 0x893b0202, 0x8c3b0202, 0x00000000, 0x8f3b0202, 0x00000000, 0x00000000, + 0x923b0202, 0x953b0202, 0x983b0202, 0x9b3b0202, 0xa13b0202, 0xa43b0202, 0x9e3b0202, 0x00000000, + 0x00000000, 0x00000000, 0xcb3b0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xaa3b0202, + 0xac3b0202, 0xae3b0202, 0xb03b0202, 0xb23b0202, 0xb43b0202, 0x00000000, 0xb63b0202, 0x00000000, + 0xb83b0202, 0xba3b0202, 0xbc3b0202, 0xbe3b0202, 0xc03b0202, 0xc23b0202, 0xc43b0202, 0xc63b0202, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0xc83b0202, 0xca3b0202, 0x8d070202, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x073c0302, 0x0d3c0302, 0x133c0302, 0x193c0302, 0x1f3c0302, 0x253c0302, 0x2b3c0302, + 0x313c0302, 0x373c0302, 0x3d3c0302, 0x433c0302, 0x493c0302, 0x4f3c0302, 0x553c0302, 0x5b3c0302, + 0x613c0302, 0x673c0302, 0x6d3c0302, 0x733c0302, 0x793c0302, 0x7f3c0302, 0x853c0302, 0x8b3c0302, + 0x913c0302, 0x973c0302, 0x9d3c0302, 0xa33c0302, 0xa93c0302, 0xaf3c0302, 0xb53c0302, 0xbb3c0302, + 0xc13c0302, 0xc73c0302, 0xcd3c0302, 0xd33c0302, 0xd93c0302, 0xdf3c0302, 0xe53c0302, 0xeb3c0302, + 0xf13c0302, 0xf73c0302, 0xfd3c0302, 0x053d0302, 0x0b3d0302, 0x113d0302, 0x173d0302, 0x1d3d0302, + 0x1e3d0302, 0x1f3d0302, 0x203d0302, 0x213d0302, 0x223d0302, 0x233d0302, 0x243d0302, 0x253d0302, + 0x263d0302, 0x273d0302, 0x283d0302, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xaa070202, + 0x023c0302, 0x033c0302, 0x043c0302, 0x053c0302, 0x063c0302, 0x293d0302, 0x2a3d0302, 0x00010800, + 0x00010300, 0x00010400, 0x00010500, 0x00010600, 0x00010900, 0x00010700, 0x2b3d0302, 0x2c3d0302, + 0x030d0f02, 0x1a0d0f02, 0x1c0d0f02, 0x1e0d0f02, 0x200d0f02, 0x220d0f02, 0x240d0f02, 0x260d0f02, + 0x280d0f02, 0x2a0d0f02, 0x2d3d0302, 0x2e3d0302, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x0a410202, 0x0c410202, 0x00000000, 0x0e410202, 0x00000000, 0x00000000, 0x10410202, + 0x12410202, 0x00000000, 0x16410202, 0x00000000, 0x00000000, 0x18410202, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1a410202, 0x1c410202, 0x1e410202, 0x20410202, + 0x00000000, 0x22410202, 0x24410202, 0x26410202, 0x28410202, 0x2a410202, 0x2c410202, 0x2e410202, + 0x00000000, 0x30410202, 0x32410202, 0x34410202, 0x00000000, 0x36410202, 0x00000000, 0x38410202, + 0x00000000, 0x00000000, 0x14410202, 0x3a410202, 0x00000000, 0x40410202, 0x42410202, 0x1d3d0202, + 0x50410a02, 0x6e414602, 0x52410e02, 0x6c414202, 0x54411202, 0x56411602, 0x58411a02, 0x5a411e02, + 0x5c412202, 0x5e412602, 0x00000000, 0x66413602, 0x67410202, 0x68410202, 0x00000000, 0x00000000, + 0x60412a02, 0x62412e02, 0x64413202, 0x6a413e02, 0x68413a02, 0x00000000, 0x06410202, 0x00000000, + 0x02410202, 0x03410202, 0x04410202, 0x05410202, 0x00000000, 0x72410202, 0x00000000, 0x00000000, + 0x030d1002, 0x1a0d1002, 0x1c0d1002, 0x1e0d1002, 0x200d1002, 0x220d1002, 0x240d1002, 0x260d1002, + 0x280d1002, 0x2a0d1002, 0x00000000, 0x00000000, 0x3c410202, 0x3e410202, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x9b0b0202, 0x9c0b0202, 0x9d0b0202, 0x9e0b0202, 0x9f0b0202, 0xa00b0202, 0xa10b0202, 0xa20b0202, + 0xa30b0202, 0xa40b0202, 0xa50b0202, 0x02075002, 0x02075502, 0xa60b0202, 0xa70b0202, 0xa80b0202, + 0xa90b0202, 0xaa0b0202, 0xab0b0202, 0xac0b0202, 0xad0b0202, 0xae0b0202, 0xaf0b0202, 0xb00b0202, + 0xb10b0202, 0xb20b0202, 0xb30b0202, 0xb40b0202, 0xb50b0202, 0xb60b0202, 0xb70b0202, 0xb80b0202, + 0x030d1102, 0x1a0d1102, 0x1c0d1102, 0x1e0d1102, 0x200d1102, 0x220d1102, 0x240d1102, 0x260d1102, + 0x280d1102, 0x2a0d1102, 0x110de102, 0x1b0d0202, 0x1d0d0202, 0x1f0d0202, 0x210d0202, 0x230d0202, + 0x250d0202, 0x270d0202, 0x290d0202, 0x020d0202, 0xb90b0202, 0xba0b0202, 0xbb0b0202, 0xbc0b0202, + 0xbd0b0202, 0x00010f00, 0xbe0b0202, 0xbf0b0202, 0xc00b0202, 0xc10b0202, 0xc20b0202, 0xc30b0202, + 0x03400202, 0x0b400202, 0x0e400202, 0x00000000, 0x2e400202, 0x3d400202, 0x42400202, 0x45400202, + 0x00000000, 0x4b400202, 0x52400212, 0x5b400212, 0x5e400212, 0x00000000, 0x78400212, 0x52400202, + 0x5b400202, 0x5e400202, 0x00000000, 0x78400202, 0x87400202, 0x90400202, 0x92400202, 0x00000000, + 0xa3400202, 0xac400202, 0xb3400202, 0xb6400202, 0x00000000, 0xbb400202, 0xbc400202, 0xbf400202, + 0xc2400202, 0xc3400202, 0xc5400202, 0xc7400202, 0xc8400202, 0xc8400212, 0xcb400202, 0xd9400202, + 0xdb400202, 0x00000000, 0xc5400212, 0xc6400202, 0xfe400202, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00010d00, 0xdc400202, 0x00000000, 0xdd400202, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0xde400202, 0xde400212, 0xdf400202, 0xdf400212, 0xa3400212, 0x00011100, + 0xdc400212, 0x00000000, 0xa3400212, 0xa3400212, 0x00010b00, 0x00011300, 0xc60b0202, 0xc70b0202, + 0x00011500, 0x00011700, 0x00011900, 0x00011b00, 0x00011e00, 0x00011c00, 0x00011d00, 0x00011f00, + 0xe0400202, 0xe1400202, 0xe2400202, 0x00000000, 0xe3400202, 0xe4400202, 0xe5400202, 0xe6400202, + 0x00000000, 0xe7400202, 0xe8400212, 0xe9400212, 0xea400212, 0x00000000, 0xeb400212, 0xe8400202, + 0xe9400202, 0xea400202, 0x00000000, 0xeb400202, 0xec400202, 0xed400202, 0xee400202, 0x00000000, + 0xef400202, 0xf0400202, 0xf1400202, 0xf2400202, 0x00000000, 0xf3400202, 0xf4400202, 0xf5400202, + 0xf6400202, 0xf7400202, 0xf8400202, 0xf9400202, 0xfa400202, 0xfa400212, 0xfb400202, 0xfc400202, + 0xfd400202, 0x00000000, 0xf3400212, 0xf7400212, 0xf8400212, 0x00000000, 0xc80b0202, 0xc90b0202, + 0xca0b0202, 0xcb0b0202, 0xcc0b0202, 0xcd0b0202, 0xce0b0202, 0xcf0b0202, 0xd00b0202, 0xd10b0202, + 0xd20b0202, 0xd30b0202, 0xd40b0202, 0xd50b0202, 0xd60b0202, 0x00000000, 0xfe0b0202, 0xd70b0202, + 0x02075202, 0x02075302, 0x02075602, 0x02075702, 0x02075802, 0x02075902, 0x02075a02, 0x02075b02, + 0x02075c02, 0x02075d02, 0x02075e02, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x033e0202, 0x053e0202, 0x073e0202, 0x0a3e0202, 0x0b3e0202, 0x0d3e0202, 0x103e0202, 0x123e0202, + 0x163e0202, 0x1a3e0202, 0x1d3e0202, 0x1e3e0202, 0x203e0202, 0x223e0202, 0x243e0202, 0x263e0202, + 0x283e0202, 0x293e0202, 0x2b3e0202, 0x2d3e0202, 0x2f3e0202, 0x333e0202, 0x343e0202, 0x393e0202, + 0x3b3e0202, 0x3c3e0202, 0x3e3e0202, 0x403e0202, 0x443e0202, 0x463e0202, 0x4c3e0202, 0x4e3e0202, + 0x543e0202, 0x643e0202, 0x653e0202, 0x663e0202, 0x673e0202, 0x683e0202, 0x693e0202, 0x6e3e0202, + 0x6f3e0202, 0x703e0202, 0x713e0202, 0x783e0203, 0x783e0202, 0x7c3e0202, 0x7e3e0202, 0x803e0202, + 0x833e0202, 0x883e0202, 0x8c3e0202, 0x7f3e0202, 0x8e3e0202, 0x8a3e0202, 0xdd070202, 0xde070202, + 0xdf070202, 0x963e0202, 0x973e0202, 0x3f3e0202, 0x433e0202, 0x473e0202, 0x513e0202, 0x4c3e0203, + 0x030d1302, 0x1a0d1302, 0x1c0d1302, 0x1e0d1302, 0x200d1302, 0x220d1302, 0x240d1302, 0x260d1302, + 0x280d1302, 0x2a0d1302, 0x4a0c0202, 0x4b0c0202, 0x4c0c0202, 0x4d0c0202, 0x4e0c0202, 0x4f0c0202, + 0x493e0202, 0x4a3e0202, 0x6a3e0202, 0x6b3e0202, 0x6c3e0202, 0x6d3e0202, 0x843e0202, 0x853e0202, + 0x863e0202, 0x873e0202, 0x0c3e0202, 0x173e0202, 0x553e0202, 0x563e0202, 0x323e0202, 0x3d3e0202, + 0x453e0202, 0x193e0202, 0x8f3e0202, 0x983e0202, 0x993e0202, 0x4b3e0202, 0x593e0202, 0x903e0202, + 0x913e0202, 0x9a3e0202, 0x9b3e0202, 0x9c3e0202, 0x9d3e0202, 0x9e3e0202, 0x273e0202, 0x573e0202, + 0x583e0202, 0x7d3e0202, 0x7a3e0202, 0x813e0202, 0x823e0202, 0x043e0202, 0x063e0202, 0x083e0202, + 0x0e3e0202, 0x143e0202, 0x1b3e0202, 0x2c3e0202, 0x303e0202, 0x353e0202, 0x363e0202, 0x3a3e0202, + 0x2a3e0202, 0x4f3e0202, 0x483e0202, 0x793e0202, 0x893e0202, 0x8b3e0202, 0x923e0202, 0x9f3e0202, + 0xa13e0202, 0xa33e0202, 0xa43e0202, 0xa03e0202, 0xa23e0202, 0xfe070202, 0x383e0202, 0xa53e0202, + 0x030d1d02, 0x1a0d1d02, 0x1c0d1d02, 0x1e0d1d02, 0x200d1d02, 0x220d1d02, 0x240d1d02, 0x260d1d02, + 0x280d1d02, 0x2a0d1d02, 0xa63e0202, 0xa73e0202, 0x7b3e0202, 0x8d3e0202, 0x500c0202, 0x510c0202, + 0x65120212, 0x66120212, 0x67120212, 0x68120212, 0x69120212, 0x6a120212, 0x6b120212, 0x6d120212, + 0x6e120212, 0x6f120212, 0x70120212, 0x71120212, 0x72120212, 0x74120212, 0x75120212, 0x76120212, + 0x77120212, 0x78120212, 0x79120212, 0x7a120212, 0x7c120212, 0x7d120212, 0x7e120212, 0x7f120212, + 0x80120212, 0x81120212, 0x82120212, 0x83120212, 0x84120212, 0x85120212, 0x86120212, 0x88120212, + 0x89120212, 0x6c120212, 0x73120212, 0x7b120212, 0x87120212, 0x8a120212, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x01120202, 0x02120202, 0x03120202, 0x04120202, 0x05120202, 0x06120202, 0x07120202, 0x09120202, + 0x0a120202, 0x0b120202, 0x0c120202, 0x0d120202, 0x0e120202, 0x10120202, 0x11120202, 0x12120202, + 0x13120202, 0x14120202, 0x15120202, 0x16120202, 0x18120202, 0x19120202, 0x1a120202, 0x1b120202, + 0x1c120202, 0x1d120202, 0x1e120202, 0x1f120202, 0x20120202, 0x21120202, 0x22120202, 0x24120202, + 0x25120202, 0x08120202, 0x0f120202, 0x17120202, 0x23120202, 0x26120202, 0x27120202, 0x28120202, + 0x29120202, 0x03123302, 0x03120202, 0xdc070202, 0x00013d00, 0x00000000, 0x00000000, 0x00000000, + 0xaa040202, 0xaa040802, 0xac040202, 0xae040202, 0xae040e02, 0xb0040202, 0xb4040202, 0xb8040202, + 0xb8042c02, 0xbe040202, 0xbe043802, 0xca040202, 0xce040202, 0xce041a02, 0xd8040202, 0xde040202, + 0xe0040202, 0xe2040202, 0xe6040202, 0xac040802, 0xac040e02, 0xac041402, 0xac042002, 0xae040802, + 0xb0042002, 0xb0043802, 0xb004b602, 0xb2040202, 0xb4042c02, 0xb6040202, 0xb8040802, 0xb8040e02, + 0xb8041402, 0xb8043202, 0xb8043802, 0xb8043e02, 0xb8044402, 0xb8044a02, 0xb8045002, 0xb8045c02, + 0xb8046202, 0xb8046e02, 0xb8047402, 0xba040202, 0xbc040202, 0xbe040802, 0xbe040e02, 0xbe041402, + 0xbe041a02, 0xbe042002, 0xbe042602, 0xbe042c02, 0xbe045002, 0xbe045c02, 0xbe046202, 0xbe046802, + 0xbe046e02, 0xbe047402, 0xbe047a02, 0xbe048002, 0xc0040202, 0xc2040202, 0xc4040202, 0xc6040202, + 0xc8040202, 0xca040e02, 0xca041a02, 0xca042602, 0xca043202, 0xca043802, 0xca044402, 0xca045002, + 0xca045602, 0xca045c02, 0xca046802, 0xca046e02, 0xcc040202, 0xce041402, 0xd0040202, 0xd2040202, + 0xd4040202, 0xd6040202, 0xd8040802, 0xd8040e02, 0xda040202, 0xdc040202, 0xe2040802, 0xe4040202, + 0xe6042602, 0xe8040202, 0xaa041402, 0xac042602, 0xac043202, 0xac044402, 0xae041a02, 0xea040202, + 0xed04a002, 0xed04a102, 0xed04a502, 0xed04a602, 0xed04aa02, 0xed04ab02, 0xed04af02, 0xed04b002, + 0xed04b402, 0xed04b502, 0xed04b602, 0xed04b702, 0xed04c102, 0xed04c202, 0xed04cb02, 0xed04ce02, + 0xed04d002, 0xed04d402, 0xed04d602, 0xed04e002, 0xed04e702, 0xed04e902, 0xed04a202, 0xed04a302, + 0xed04a702, 0xed04a802, 0xed04ac02, 0xed04ad02, 0xed04ae02, 0xed04b202, 0xed04b302, 0xed04ba02, + 0xed04bb02, 0xed04bd02, 0xed04be02, 0xed04c002, 0xed04c502, 0xed04c602, 0xed04c802, 0xed04c902, + 0xed04ca02, 0xed04cc02, 0xed04cd02, 0xed04cf02, 0xed04d202, 0xed04d302, 0xed04d702, 0xed04d902, + 0xed04da02, 0xed04db02, 0xed04dc02, 0xed04de02, 0xed04df02, 0xed04e502, 0xed04e602, 0xed04e802, + 0xed04ea02, 0xed04eb02, 0xed04f002, 0xed04f302, 0xed04f502, 0xed04f702, 0xed04f802, 0xed04fa02, + 0xed04fc02, 0xed04fd02, 0xed04fe02, 0xed04a402, 0xed04a902, 0xed04b102, 0xed04b802, 0xed04b902, + 0xaa040204, 0xaa040804, 0xaa042604, 0xac040204, 0xac043204, 0xac044404, 0xae040204, 0xb0040204, + 0xb0040804, 0xb0044404, 0xb0045c04, 0xb0048604, 0xb004aa04, 0xb004b004, 0xb004b604, 0xb4040204, + 0xb8040204, 0xb8043204, 0xbe040204, 0xbe043804, 0xca040204, 0xce040204, 0xd8040204, 0xde040204, + 0xe0040204, 0xe2040204, 0xe6040204, 0xaa041a04, 0xaa042c04, 0xac040804, 0xac041404, 0xac042604, + 0xac042c04, 0xac043e04, 0xae040804, 0xae041a04, 0xb0041404, 0xb0042004, 0xb0042604, 0xb0043204, + 0xb0043804, 0xb0044a04, 0xb0045004, 0xb0046e04, 0xb0047a04, 0xb0048004, 0xb0048c04, 0xb0049204, + 0xb004a404, 0xb004bc04, 0xb4040804, 0xb4042004, 0xb4042c04, 0xb4043804, 0xb4043e04, 0xb4044404, + 0xb4045004, 0xb4045604, 0xb6040204, 0xb8041a04, 0xb8047404, 0xb8047a04, 0xba040204, 0xbe040804, + 0xbe041404, 0xbe041a04, 0xbe042604, 0xc8040204, 0xca040e04, 0xca041404, 0xca045004, 0xca046204, + 0xca040804, 0xca043e04, 0xca044a04, 0xe2040804, 0xe4040204, 0xe6040804, 0xe6040e04, 0xe6041404, + 0xe6041a04, 0xe8040204, 0xaa040e04, 0xaa042004, 0xaa043204, 0xaa043804, 0xaa043e04, 0xac040e04, + 0x02520202, 0x03520202, 0x05520202, 0x02520802, 0x06520202, 0x07520202, 0x08520202, 0x12530202, + 0x0a520202, 0x0b520202, 0x0c520202, 0x0d520202, 0x0e520202, 0x0f520202, 0x10520202, 0x11520202, + 0x02520402, 0x03520402, 0x05520402, 0x02520a02, 0x06520402, 0x07520402, 0x08520402, 0x09520202, + 0x12520202, 0x13520202, 0x14520202, 0x15520202, 0x16520202, 0x17520202, 0x18520202, 0x19520202, + 0x1a520202, 0x1b520202, 0x1c520202, 0x1d520202, 0x1e520202, 0x1f520202, 0x20520202, 0x21520202, + 0x22520202, 0x23520202, 0x24520202, 0x25520202, 0x26520202, 0x27520202, 0x28520202, 0x29520202, + 0x1a520402, 0x1b520402, 0x1c520402, 0x1d520402, 0x1e520402, 0x1f520402, 0x20520402, 0x21520402, + 0x2a520202, 0x2b520202, 0x2c520202, 0x2d520202, 0x2e520202, 0x2f520202, 0x30520202, 0x31520202, + 0x32520202, 0x33520202, 0x34520202, 0x35520202, 0x36520202, 0x38520202, 0x39520202, 0x13530202, + 0x37520202, 0x00000000, 0x34520402, 0x3a520202, 0x43520202, 0x33520402, 0x00000000, 0x00000000, + 0x3b520202, 0x3c520202, 0x3d520202, 0x3e520202, 0x3f520202, 0x40520202, 0x41520202, 0x00000000, + 0x3f520402, 0x00000000, 0x3d520402, 0x42520202, 0x2c527f02, 0x3c520402, 0x00000000, 0x00000000, + 0x44520202, 0x45520202, 0x46520202, 0x47520202, 0x48520202, 0x49520202, 0x4a520202, 0x4b520202, + 0xf8520202, 0xf9520202, 0xfa520202, 0xfb520202, 0xfc520202, 0xfd520202, 0xfe520202, 0xff520202, + 0x4c520202, 0x4d520202, 0x4e520202, 0x4f520202, 0x50520202, 0x51520202, 0x52520202, 0x53520202, + 0x54520202, 0x55520202, 0x56520202, 0x57520202, 0x58520202, 0x59520202, 0x5a520202, 0x5b520202, + 0x02520602, 0x03520602, 0x05520602, 0x02520c02, 0x06520602, 0x07520602, 0x08520602, 0x14530202, + 0x02520e02, 0x00000000, 0x05520802, 0x09520402, 0x06520802, 0x07520802, 0x00000000, 0x00000000, + 0x5c520202, 0x5d520202, 0x5e520202, 0x5f520202, 0x60520202, 0x61520202, 0x62520202, 0x63520202, + 0x64520202, 0x65520202, 0x66520202, 0x67520202, 0x68520202, 0x69520202, 0x6a520202, 0x6b520202, + 0x6c520202, 0x6d520202, 0x6e520202, 0x6f520202, 0x70520202, 0x71520202, 0x72520202, 0x73520202, + 0x74520202, 0x75520202, 0x76520202, 0x77520202, 0x78520202, 0x79520202, 0x7a520202, 0x15530202, + 0x7a520402, 0x00000000, 0x76520402, 0x7b520202, 0x78520402, 0x75520402, 0x00000000, 0x00000000, + 0x7c520202, 0x7d520202, 0x7e520202, 0x7f520202, 0x80520202, 0x81520202, 0x82520202, 0x00000000, + 0x82520402, 0x00000000, 0x7e520402, 0x83520202, 0x80520402, 0x7d520402, 0x00000000, 0x00000000, + 0x84520202, 0x89520202, 0x85520202, 0x86520202, 0x87520202, 0x88520202, 0x8a520202, 0x16530202, + 0x6c520402, 0x6d520402, 0x6e520402, 0x6f520402, 0x70520402, 0x71520402, 0x72520402, 0x00000000, + 0x8b520202, 0x8c520202, 0x8d520202, 0x8e520202, 0x8f520202, 0x90520202, 0x91520202, 0x92520202, + 0x93520202, 0x94520202, 0x95520202, 0x96520202, 0x97520202, 0x98520202, 0x99520202, 0x9a520202, + 0x9b520202, 0x9c520202, 0x9d520202, 0x9e520202, 0x9f520202, 0xa0520202, 0xa1520202, 0x17530202, + 0xa2520202, 0xa3520202, 0xa4520202, 0xa5520202, 0xa6520202, 0xa7520202, 0xa8520202, 0xa9520202, + 0xaa520202, 0xab520202, 0xac520202, 0xad520202, 0xae520202, 0xaf520202, 0xb0520202, 0xb1520202, + 0xb2520202, 0xb3520202, 0xb4520202, 0xb5520202, 0xb6520202, 0xb7520202, 0xb8520202, 0xb9520202, + 0xba520202, 0xbb520202, 0xbc520202, 0xbd520202, 0xbe520202, 0xbf520202, 0xc0520202, 0x18530202, + 0xc0520402, 0x00000000, 0xbc520402, 0xc1520202, 0xbe520402, 0xbb520402, 0x00000000, 0x00000000, + 0xc2520202, 0xc3520202, 0xc4520202, 0xc5520202, 0xc6520202, 0xc7520202, 0xc8520202, 0x19530202, + 0xc9520202, 0xca520202, 0xcb520202, 0xcc520202, 0xcd520202, 0xce520202, 0xcf520202, 0xd0520202, + 0xd1520202, 0xd2520202, 0xd3520202, 0xd4520202, 0xd5520202, 0xd6520202, 0xd7520202, 0xd8520202, + 0xd9520202, 0xda520202, 0xdb520202, 0xdc520202, 0xdd520202, 0xde520202, 0xdf520202, 0xe0520202, + 0xe1520202, 0xe2520202, 0xe3520202, 0xe4520202, 0xe5520202, 0xe6520202, 0xe7520202, 0xe8520202, + 0xe1520402, 0xe2520402, 0xe3520402, 0xe4520402, 0xe5520402, 0xe6520402, 0xe7520402, 0x1a530202, + 0xe9520202, 0xea520202, 0xeb520202, 0xec520202, 0xed520202, 0xee520202, 0xef520202, 0xf0520202, + 0xf1520202, 0xf2520202, 0xf3520202, 0xf4520202, 0xf5520202, 0xf6520202, 0xf7520202, 0xf1520402, + 0x22520402, 0x12520402, 0xe9520402, 0x00000000, 0x00000000, 0x00015300, 0x00015200, 0x00015100, + 0x14093302, 0x0001b700, 0x0001b800, 0x0001b900, 0x0001ba00, 0x0001bb00, 0x0001bc00, 0x0001bd00, + 0x0001be00, 0x1a0d1402, 0x1c0d1402, 0x1e0d1402, 0x200d1402, 0x220d1402, 0x240d1402, 0x260d1402, + 0x280d1402, 0x2a0d1402, 0x2c0d1402, 0x360d1402, 0x400d1402, 0x4a0d1402, 0x540d1402, 0x560d1402, + 0x580d1402, 0x5a0d1402, 0x5c0d1402, 0x5e0d1402, 0x640d1402, 0x00000000, 0x00000000, 0x00000000, + 0x02530202, 0x03530202, 0x04530202, 0x05530202, 0x06530202, 0x07530202, 0x08530202, 0x09530202, + 0x0a530202, 0x0b530202, 0x0c530202, 0x0d530202, 0x0e530202, 0x0f530202, 0x10530202, 0x11530202, + 0x15090202, 0x16090202, 0x17090202, 0x18090202, 0x19090202, 0x1a090202, 0x1b090202, 0x1c090202, + 0x1d090202, 0x1e090202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x03470202, 0x04470202, 0x05470202, 0x06470202, 0x07470202, 0x08470202, 0x09470202, 0x0a470202, + 0x0b470202, 0x0c470202, 0x0d470202, 0x0e470202, 0x0f470202, 0x10470202, 0x11470202, 0x12470202, + 0x13470202, 0x14470202, 0x15470202, 0x16470202, 0x17470202, 0x18470202, 0x19470202, 0x1a470202, + 0x1b470202, 0x1c470202, 0x1d470202, 0x1e470202, 0x1f470202, 0x20470202, 0x21470202, 0x22470202, + 0x23470202, 0x24470202, 0x25470202, 0x26470202, 0x27470202, 0x28470202, 0x29470202, 0x2a470202, + 0x2b470202, 0x2c470202, 0x2d470202, 0x2e470202, 0x2f470202, 0x30470202, 0x31470202, 0x32470202, + 0x33470202, 0x34470202, 0x35470202, 0x36470202, 0x37470202, 0x38470202, 0x39470202, 0x3a470202, + 0x3b470202, 0x3c470202, 0x3d470202, 0x3e470202, 0x3f470202, 0x40470202, 0x41470202, 0x42470202, + 0x43470202, 0x44470202, 0x45470202, 0x46470202, 0x47470202, 0x48470202, 0x49470202, 0x4a470202, + 0x4b470202, 0x4c470202, 0x4d470202, 0x4e470202, 0x4f470202, 0x50470202, 0x51470202, 0x52470202, + 0x53470202, 0x54470202, 0x55470202, 0x56470202, 0x57470202, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xff090202, 0x00000000, 0x00000000, 0x04440202, 0x04440a02, 0x06440202, 0x06440a02, 0xc3440902, + 0xc3442602, 0xc3444302, 0x08440202, 0x08440a02, 0xc3446002, 0xc3447d02, 0xc3449a02, 0xc344b702, + 0xc344d402, 0xc4440902, 0xc4442602, 0xc4444302, 0xc4446002, 0xc4447d02, 0xc4449a02, 0xc444b702, + 0xc444d402, 0xc5440902, 0xc5442602, 0xc5444302, 0xc5446002, 0xc5447d02, 0xc5449a02, 0xc544b702, + 0xc544d402, 0xc6440902, 0xc6442602, 0xc6444302, 0xc6446002, 0xc6447d02, 0xc6449a02, 0xc644b702, + 0xc644d402, 0xc7440902, 0xc7442602, 0xc7444302, 0xc7446002, 0xc7447d02, 0xc7449a02, 0x00000000, + 0x00000000, 0x0e440202, 0x0e440a02, 0x10440202, 0x10440a02, 0xc744b702, 0xc744d402, 0xc8440902, + 0x12440202, 0x12440a02, 0xc8442602, 0xc8444302, 0xc8446002, 0xc8447d02, 0xc8449a02, 0xc844b702, + 0xc844d402, 0xc9440902, 0xc9442602, 0xc9444302, 0xc9446002, 0xc9447d02, 0xc9449a02, 0xc944b702, + 0xc944d402, 0x14440202, 0xca440902, 0xca442602, 0x00000000, 0x00000000, 0x18440202, 0x18440a02, + 0x1a440202, 0x1a440a02, 0xca444302, 0xca446002, 0xca447d02, 0x1c440202, 0x1c440a02, 0xca449a02, + 0xca44b702, 0xca44d402, 0xcb440902, 0xcb442602, 0xcb444302, 0xcb446002, 0xcb447d02, 0xcb449a02, + 0xcb44b702, 0xcb44d402, 0xcc440902, 0xcc442602, 0xcc444302, 0xcc446002, 0x1e440202, 0xcc447d02, + 0xcc449a02, 0xcc44b702, 0xcc44d402, 0x00000000, 0x00000000, 0x22440202, 0x22440a02, 0x24440202, + 0x24440a02, 0xcd440902, 0x26440202, 0x26440a02, 0xcd442602, 0xcd444302, 0xcd446002, 0xcd447d02, + 0xcd449a02, 0xcd44b702, 0xcd44d402, 0xce440902, 0xce442602, 0xce444302, 0xce446002, 0xce447d02, + 0xce449a02, 0xce44b702, 0xce44d402, 0x28440202, 0xcf440902, 0xcf442602, 0xcf444302, 0xcf446002, + 0xcf447d02, 0x00000000, 0x00000000, 0x2c440202, 0x2c440a02, 0x2e440202, 0x2e440a02, 0xcf449a02, + 0x30440202, 0x30440a02, 0xcf44b702, 0xcf44d402, 0xd0440902, 0xd0442602, 0xd0444302, 0xd0446002, + 0xd0447d02, 0xd0449a02, 0xd044b702, 0xd044d402, 0xd1440902, 0xd1442602, 0xd1444302, 0xd1446002, + 0xd1447d02, 0x32440202, 0xd1449a02, 0x00000000, 0x00000000, 0x36440202, 0x36440a02, 0x38440202, + 0x38440a02, 0xd144b702, 0x3a440202, 0x3a440a02, 0xd144d402, 0xd2440902, 0xd2442602, 0xd2444302, + 0xd2446002, 0xd2447d02, 0xd2449a02, 0xd244b702, 0xd244d402, 0xd3440902, 0xd3442602, 0xd3444302, + 0xd3446002, 0xd3447d02, 0xd3449a02, 0x3c440202, 0xd344b702, 0xd344d402, 0xd4440902, 0xd4442602, + 0x00000000, 0x00000000, 0x40440202, 0x40440a02, 0x42440202, 0x42440a02, 0xd4444302, 0x44440202, + 0x44440a02, 0xd4446002, 0xd4447d02, 0xd4449a02, 0xd444b702, 0xd444d402, 0xd5440902, 0xd5442602, + 0x46440202, 0xd5444302, 0xd5446002, 0x00000000, 0x00000000, 0x54440202, 0x54440a02, 0x56440202, + 0x56440a02, 0xd5447d02, 0x58440202, 0x58440a02, 0xd5449a02, 0xd544b702, 0xd544d402, 0xd6440902, + 0xd6442602, 0xd6444302, 0xd6446002, 0xd6447d02, 0xd6449a02, 0xd644b702, 0xd644d402, 0xd7440902, + 0xd7442602, 0xd7444302, 0x5a440202, 0xd7446002, 0xd7447d02, 0x00000000, 0x00000000, 0x4a440202, + 0x4a440a02, 0x4c440202, 0x4c440a02, 0xd7449a02, 0x4e440202, 0x4e440a02, 0xd744b702, 0xd744d402, + 0xd8440902, 0xd8442602, 0xd8444302, 0xd8446002, 0xd8447d02, 0xd8449a02, 0xd844b702, 0xd844d402, + 0xd9440902, 0xd9442602, 0xd9444302, 0xd9446002, 0xd9447d02, 0x50440202, 0xd9449a02, 0xd944b702, + 0xd944d402, 0xda440902, 0xda442602, 0xda444302, 0xda446002, 0xda447d02, 0xda449a02, 0xda44b702, + 0xda44d402, 0xdb440902, 0xdb442602, 0xdb444302, 0xdb446002, 0xdb447d02, 0xdb449a02, 0xdb44b702, + 0xdb44d402, 0xdc440902, 0xdc442602, 0xdc444302, 0xdc446002, 0xdc447d02, 0xdc449a02, 0xdc44b702, + 0xdc44d402, 0xdd440902, 0xdd442602, 0xdd444302, 0xdd446002, 0xdd447d02, 0x00000000, 0x00000000, + 0x5e440202, 0x5e440a02, 0x60440202, 0x60440a02, 0xdd449a02, 0x62440202, 0x62440a02, 0xdd44b702, + 0xdd44d402, 0xde440902, 0xde442602, 0xde444302, 0xde446002, 0xde447d02, 0xde449a02, 0xde44b702, + 0xde44d402, 0xdf440902, 0xdf442602, 0xdf444302, 0xdf446002, 0xdf447d02, 0x64440202, 0xdf449a02, + 0xdf44b702, 0xdf44d402, 0x00000000, 0xe0440902, 0xe0442602, 0x00000000, 0x72440202, 0x72440a02, + 0x74440202, 0x74440a02, 0xe0444302, 0x76440202, 0x76440a02, 0xe0446002, 0xe0447d02, 0xe0449a02, + 0x78440202, 0xe044b702, 0xe044d402, 0x00000000, 0x00000000, 0x68440202, 0x68440a02, 0x6a440202, + 0x6a440a02, 0x6c440202, 0x6c440a02, 0xe1440902, 0xe1442602, 0x6e440202, 0xe1444302, 0xe1446002, + 0xe1447d02, 0xe1449a02, 0xe144b702, 0xe144d402, 0xe2440902, 0xe2442602, 0xe2444302, 0xe2446002, + 0xe2447d02, 0xe2449a02, 0xe244b702, 0xe244d402, 0xe3440902, 0xe3442602, 0xe3444302, 0xe3446002, + 0xe3447d02, 0xe3449a02, 0xe344b702, 0xe344d402, 0xe4440902, 0xe4442602, 0xe4444302, 0xe4446002, + 0xe4447d02, 0xe4449a02, 0xe444b702, 0xe444d402, 0xb4440202, 0xe5440902, 0x00000000, 0x7c440202, + 0x7c440a02, 0x7e440202, 0x7e440a02, 0x80440202, 0x80440a02, 0x82440202, 0xe5442602, 0xe5444302, + 0xe5446002, 0xe5447d02, 0xe5449a02, 0xe544b702, 0xe544d402, 0xe6440902, 0x00000000, 0x86440202, + 0x86440a02, 0x88440202, 0x88440a02, 0x8a440202, 0x8a440a02, 0x8c440202, 0x96440202, 0xe6442602, + 0xe6444302, 0xe6446002, 0xe6447d02, 0xe6449a02, 0xe644b702, 0xe644d402, 0xe7440902, 0xe7442602, + 0xa4440202, 0xa4440a02, 0xa6440202, 0xa6440a02, 0xa8440202, 0xa8440a02, 0xaa440202, 0xe7444302, + 0x9a440202, 0x9a440a02, 0x9c440202, 0x9c440a02, 0x9e440202, 0x9e440a02, 0xa0440202, 0xe7446002, + 0xe7447d02, 0xe7449a02, 0xe744b702, 0xe744d402, 0xe8440902, 0xe8442602, 0xe8444302, 0xe8446002, + 0xe8447d02, 0xe8449a02, 0xe844b702, 0xe844d402, 0xe9440902, 0xe9442602, 0xe9444302, 0xe9446002, + 0xe9447d02, 0xe9449a02, 0xe944b702, 0xe944d402, 0xea440902, 0xea442602, 0xea444302, 0xea446002, + 0xea447d02, 0xea449a02, 0xea44b702, 0xea44d402, 0xeb440902, 0xeb442602, 0xeb444302, 0xeb446002, + 0xeb447d02, 0xeb449a02, 0xeb44b702, 0xeb44d402, 0xec440902, 0xec442602, 0xec444302, 0xec446002, + 0xec447d02, 0xec449a02, 0xec44b702, 0xec44d402, 0xed440902, 0xed442602, 0xed444302, 0xed446002, + 0xed447d02, 0xed449a02, 0xed44b702, 0xed44d402, 0xee440902, 0xee442602, 0xee444302, 0xee446002, + 0xee447d02, 0xee449a02, 0xee44b702, 0xee44d402, 0xef440902, 0xef442602, 0xef444302, 0xef446002, + 0xef447d02, 0xef449a02, 0xef44b702, 0xef44d402, 0xf0440902, 0xf0442602, 0xf0444302, 0xf0446002, + 0xf0447d02, 0xf0449a02, 0xf044b702, 0xf044d402, 0xf1440902, 0xf1442602, 0xf1444302, 0xf1446002, + 0xf1447d02, 0xf1449a02, 0xf144b702, 0xf144d402, 0xf2440902, 0xf2442602, 0xf2444302, 0xf2446002, + 0xf2447d02, 0xf2449a02, 0xf244b702, 0xf244d402, 0xf3440902, 0xf3442602, 0xf3444302, 0xf3446002, + 0xf3447d02, 0xf3449a02, 0xf344b702, 0xf344d402, 0xf4440902, 0xf4442602, 0xf4444302, 0xf4446002, + 0xf4447d02, 0xf4449a02, 0xf444b702, 0xf444d402, 0xf5440902, 0xf5442602, 0xf5444302, 0xf5446002, + 0xf5447d02, 0xf5449a02, 0xf544b702, 0xf544d402, 0xf6440902, 0xf6442602, 0xf6444302, 0xf6446002, + 0xf6447d02, 0xf6449a02, 0xf644b702, 0xf644d402, 0xf7440902, 0xf7442602, 0xf7444302, 0xf7446002, + 0xf7447d02, 0xf7449a02, 0xf744b702, 0xf744d402, 0xf8440902, 0xf8442602, 0xf8444302, 0xf8446002, + 0xf8447d02, 0xf8449a02, 0xf844b702, 0xf844d402, 0xf9440902, 0xf9442602, 0xf9444302, 0xf9446002, + 0xf9447d02, 0xf9449a02, 0xf944b702, 0xf944d402, 0xfa440902, 0xfa442602, 0xfa444302, 0xfa446002, + 0xfa447d02, 0xfa449a02, 0xfa44b702, 0xfa44d402, 0xfb440902, 0xfb442602, 0xfb444302, 0xfb446002, + 0xfb447d02, 0xfb449a02, 0xfb44b702, 0xfb44d402, 0xfc440902, 0xfc442602, 0xfc444302, 0xfc446002, + 0xfc447d02, 0xfc449a02, 0xfc44b702, 0xfc44d402, 0xfd440902, 0xfd442602, 0xfd444302, 0xfd446002, + 0xfd447d02, 0xfd449a02, 0xfd44b702, 0xfd44d402, 0xfe440902, 0xfe442602, 0xfe444302, 0xfe446002, + 0xfe447d02, 0xfe449a02, 0xfe44b702, 0xfe44d402, 0xff440902, 0xbe440202, 0x8f072102, 0x00000000, + 0x00000000, 0x90440202, 0x90440a02, 0x92440202, 0x92440a02, 0x94440202, 0x94440a02, 0xff440a02, + 0xff440b02, 0xff440c02, 0xff440d02, 0xff440e02, 0xff440f02, 0xff441002, 0xff441102, 0xff441202, + 0x02074902, 0x04490202, 0x05490202, 0x06490202, 0x07490202, 0x08490202, 0x09490202, 0x0a490202, + 0x0b490202, 0x0c490202, 0x0d490202, 0x0e490202, 0x0f490202, 0x10490202, 0x11490202, 0x12490202, + 0x13490202, 0x14490202, 0x15490202, 0x16490202, 0x17490202, 0x18490202, 0x19490202, 0x1a490202, + 0x1b490202, 0x1c490202, 0x1d490202, 0x90070202, 0x91070202, 0x00000000, 0x00000000, 0x00000000, + 0x05480202, 0x05480b02, 0x07480202, 0x3d480202, 0x07480b02, 0x07481402, 0x09480202, 0x09480b02, + 0x0b480202, 0x0b480b02, 0x39480202, 0x3b480202, 0x0b481402, 0x0b481d02, 0x0b482602, 0x0d480202, + 0x0f480202, 0x11480202, 0x13480202, 0x13480b02, 0x13481402, 0x13481d02, 0x13482602, 0x15480202, + 0x43480202, 0x17480202, 0x19480202, 0x19480b02, 0x19481402, 0x19481d02, 0x1b480202, 0x1b480b02, + 0x1b481402, 0x1d480202, 0x1d480b02, 0x1f480202, 0x1f480b02, 0x21480202, 0x21480b02, 0x23480202, + 0x25480202, 0x27480202, 0x29480202, 0x29480b02, 0x29481d02, 0x29482602, 0x29482f02, 0x2a480202, + 0x2a480b02, 0x2a481402, 0x2b480202, 0x2b480b02, 0x2b481402, 0x25480b02, 0x2d480202, 0x2f480202, + 0x2f480b02, 0x2f481402, 0x31480202, 0x31480b02, 0x33480202, 0x33480b02, 0x35480202, 0x37480202, + 0x3f480202, 0x47480202, 0x49480202, 0x41480202, 0x45480202, 0x4b480202, 0x4d480202, 0x4d480b02, + 0x4d481402, 0x17480b02, 0x29481402, 0x00017000, 0x00017100, 0x00017200, 0x21481402, 0x2f481d02, + 0x09481402, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x034a0202, 0x044a0202, 0x054a0202, 0x064a0202, 0x074a0202, 0x084a0202, 0x094a0202, 0x0a4a0202, + 0x0b4a0202, 0x0c4a0202, 0x0d4a0202, 0x0e4a0202, 0x0f4a0202, 0x00000000, 0x104a0202, 0x114a0202, + 0x124a0202, 0x134a0202, 0x144a0202, 0x154a0202, 0x164a0202, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x354a0202, 0x364a0202, 0x374a0202, 0x384a0202, 0x394a0202, 0x3a4a0202, 0x3b4a0202, 0x3c4a0202, + 0x3d4a0202, 0x3e4a0202, 0x3f4a0202, 0x404a0202, 0x414a0202, 0x424a0202, 0x434a0202, 0x444a0202, + 0x454a0202, 0x464a0202, 0x474a0202, 0x484a0202, 0x494a0202, 0x89070202, 0x8a070202, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x674a0202, 0x684a0202, 0x694a0202, 0x6a4a0202, 0x6b4a0202, 0x6c4a0202, 0x6d4a0202, 0x6e4a0202, + 0x6f4a0202, 0x704a0202, 0x714a0202, 0x724a0202, 0x734a0202, 0x744a0202, 0x754a0202, 0x764a0202, + 0x774a0202, 0x784a0202, 0x794a0202, 0x7a4a0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x964a0202, 0x974a0202, 0x984a0202, 0x994a0202, 0x9a4a0202, 0x9b4a0202, 0x9c4a0202, 0x9d4a0202, + 0x9e4a0202, 0x9f4a0202, 0xa04a0202, 0xa14a0202, 0xa24a0202, 0x00000000, 0xa34a0202, 0xa44a0202, + 0xa54a0202, 0x00000000, 0xa64a0202, 0xa74a0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x0a430202, 0x0c430202, 0x0e430202, 0x10430202, 0x12430202, 0x14430202, 0x16430202, 0x18430202, + 0x1a430202, 0x1c430202, 0x1e430202, 0x20430202, 0x22430202, 0x24430202, 0x26430202, 0x28430202, + 0x2a430202, 0x2c430202, 0x2e430404, 0x32430202, 0x34430202, 0x38430202, 0x3a430202, 0x3c430202, + 0x3e430202, 0x40430202, 0x42430202, 0x4a430202, 0x4e430202, 0x50430202, 0x52430202, 0x54430202, + 0x56430202, 0x58430202, 0x5a430202, 0x5a430202, 0x5a430602, 0x5a430802, 0x5a430a02, 0x5a430c02, + 0x5a430e02, 0x5a431002, 0x5a431202, 0x42430602, 0x42430802, 0x4a430402, 0x4a430602, 0x5a431402, + 0x5a431602, 0x5a431802, 0x5a431802, 0x5a431c02, 0x70430202, 0x6e430202, 0x72430202, 0x74430202, + 0x76430202, 0x78430202, 0x7a430202, 0x7c430202, 0x7e430202, 0x80430202, 0x82430202, 0x84430202, + 0x86430202, 0x88430202, 0x8a430202, 0x8c430202, 0x8e430202, 0x90430202, 0x94430202, 0xa0430202, + 0xa2430202, 0x68430202, 0x6a430202, 0xa6430202, 0x42430402, 0xaa430202, 0xa4430202, 0xac430202, + 0xa8430202, 0xae430202, 0x92430202, 0xe8430202, 0xf0430202, 0xf1430202, 0xf2430202, 0xf3430202, + 0xf4430202, 0xf5430202, 0xf6430202, 0xb0070202, 0x02430202, 0x04430202, 0x00000000, 0x00000000, + 0x030d1502, 0x1a0d1502, 0x1c0d1502, 0x1e0d1502, 0x200d1502, 0x220d1502, 0x240d1502, 0x260d1502, + 0x280d1502, 0x2a0d1502, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xb4430202, 0xb5430202, 0xb6430202, 0xb7430202, 0xb8430202, 0xb9430202, 0xba430202, 0xbb430202, + 0xbc430202, 0xbd430202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x3c0c0202, 0x3d0c0202, 0x0e075102, 0x3e0c0202, 0x13075102, 0x3f0c0202, 0x00000000, 0x400c0202, + 0x0e075902, 0x410c0202, 0x420c0202, 0x00000000, 0x00000000, 0x00000000, 0x02073f02, 0x00000000, + 0x030d1602, 0x1a0d1602, 0x1c0d1602, 0x1e0d1602, 0x200d1602, 0x220d1602, 0x240d1602, 0x260d1602, + 0x280d1602, 0x2a0d1602, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x0a3f0202, 0x0d3f0202, 0x103f0202, 0x163f0202, 0x193f0202, 0x1c3f0202, 0x1f3f0202, 0x223f0202, + 0x253f0202, 0x283f0202, 0x2e3f0202, 0x313f0202, 0x343f0202, 0x373f0202, 0x403f0202, 0x433f0202, + 0x463f0202, 0x493f0202, 0x5b3f0202, 0x5e3f0202, 0x613f0202, 0x6a3f0202, 0x703f0202, 0x763f0202, + 0x793f0202, 0x7c3f0202, 0x7f3f0202, 0x823f0202, 0x853f0202, 0x883f0202, 0x8e3f0202, 0x913f0202, + 0x943f0202, 0x973f0202, 0x9a3f0202, 0x073f0202, 0x0d3f0602, 0x103f0602, 0x163f0602, 0x193f0602, + 0x1c3f0602, 0x1f3f0602, 0x283f0602, 0x2e3f0602, 0x313f0602, 0x343f0602, 0x373f0602, 0x403f0602, + 0x5b3f0602, 0x5e3f0602, 0x613f0602, 0x6a3f0602, 0x853f0602, 0x703f0602, 0x793f0602, 0x7f3f0602, + 0x8b3f0202, 0x8e3f0602, 0x9d3f0202, 0xa03f0202, 0x643f0202, 0x0d3f0a02, 0x103f0a02, 0x133f0202, + 0x1f3f0a02, 0x193f0a02, 0x283f0a02, 0x7f3f0a02, 0x373f0a02, 0x3d3f0202, 0x313f0a02, 0x493f0602, + 0x5b3f0a02, 0x5e3f0a02, 0x6a3f0a02, 0x7c3f0602, 0x8b3f0602, 0x8e3f0a02, 0x853f0a02, 0x883f0602, + 0xa33f0202, 0x613f0a02, 0x6d3f0602, 0x103f0e02, 0x7f3f0e02, 0x763f0602, 0x7c3f0a02, 0x6d3f0202, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xe93f0202, 0xec3f0202, 0xef3f0202, 0xf23f0202, 0xf53f0202, 0xf83f0202, 0xfb3f0202, 0x0a3f0602, + 0x103f1202, 0x7f3f1202, 0x2b3f0202, 0x673f0202, 0xa63f0202, 0xac3f0202, 0xaf3f0202, 0xb53f0202, + 0xb83f0202, 0xc23f0202, 0xc83f0202, 0xcb3f0202, 0xd13f0202, 0xd73f0202, 0xda3f0202, 0xdd3f0202, + 0xbf3f0202, 0xd73f0602, 0x3a3f0202, 0x2b3f0602, 0x4c3f0202, 0x4f3f0202, 0xa93f0202, 0xb23f0202, + 0xbf3f0602, 0xc53f0202, 0x523f0202, 0xd43f0202, 0x553f0202, 0x583f0202, 0xe03f0202, 0xe33f0202, + 0xce3f0202, 0xe63f0202, 0xe43f0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xff441302, 0xff441402, 0xff441502, 0xff441602, 0xff441702, 0xff441802, 0xff441902, 0xff441a02, + 0xff441b02, 0xff441c02, 0xff441d02, 0xff441e02, 0xff441f02, 0xff442002, 0xff442102, 0xff442202, + 0xff442302, 0xff442402, 0xff442502, 0xff442602, 0xff442702, 0xff442802, 0xff442902, 0xff442a02, + 0xff442b02, 0xff442c02, 0xff442d02, 0xff442e02, 0xff442f02, 0xff443002, 0xff443102, 0xff443202, + 0xff443302, 0xff443402, 0xff443502, 0xff443602, 0xff443702, 0xff443802, 0xff443902, 0xff443a02, + 0xff443b02, 0xff443c02, 0xff443d02, 0xff443e02, 0xff443f02, 0xff444002, 0xff444102, 0xff444202, + 0xff444302, 0xff444402, 0xff444502, 0xff444602, 0xff444702, 0xff444802, 0xff444902, 0xff444a02, + 0xff444b02, 0xff444c02, 0xff444d02, 0xff444e02, 0xff444f02, 0xff445002, 0xff445102, 0xff445202, + 0xff445302, 0xff445402, 0xff445502, 0xff445602, 0xff445702, 0xff445802, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x35490202, 0x36490202, 0x37490202, 0x38490202, 0x39490202, 0x3a490202, 0x3b490202, 0x3c490202, + 0x3d490202, 0x3e490202, 0x3f490202, 0x40490202, 0x41490202, 0x42490202, 0x43490202, 0x44490202, + 0x45490202, 0x46490202, 0x47490202, 0x48490202, 0x49490202, 0x4a490202, 0x4b490202, 0x4c490202, + 0x4d490202, 0x4e490202, 0x4f490202, 0x50490202, 0x51490202, 0x00000000, 0x00000000, 0x00000000, + 0x52490202, 0x53490202, 0x54490202, 0x55490202, 0x56490202, 0x57490202, 0x58490202, 0x59490202, + 0x5a490202, 0x5b490202, 0x5c490202, 0x5d490202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x5e490202, 0x5f490202, 0x60490202, 0x61490202, 0x62490202, 0x63490202, 0x64490202, 0x65490202, + 0x66490202, 0x67490202, 0x68490202, 0x69490202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xf80b0202, 0x00000000, 0x00000000, 0x00000000, 0x07075102, 0x15075102, 0x030d1702, 0x1a0d1702, + 0x1c0d1702, 0x1e0d1702, 0x200d1702, 0x220d1702, 0x240d1702, 0x260d1702, 0x280d1702, 0x2a0d1702, + 0x85490202, 0x86490202, 0x87490202, 0x88490202, 0x89490202, 0x8a490202, 0x8b490202, 0x8c490202, + 0x8d490202, 0x8e490202, 0x8f490202, 0x90490202, 0x91490202, 0x92490202, 0x93490202, 0x94490202, + 0x95490202, 0x96490202, 0x97490202, 0x98490202, 0x99490202, 0x9a490202, 0x9b490202, 0x9c490202, + 0x9d490202, 0x9e490202, 0x9f490202, 0xa0490202, 0xa1490202, 0xa2490202, 0x00000000, 0x00000000, + 0xa3490202, 0xa4490202, 0xa5490202, 0xa6490202, 0xa7490202, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x024c0202, 0x034c0202, 0x044c0202, 0x054c0202, 0x064c0202, 0x074c0202, 0x084c0202, 0x094c0202, + 0x0a4c0202, 0x0b4c0202, 0x0c4c0202, 0x0d4c0202, 0x0e4c0202, 0x0f4c0202, 0x104c0202, 0x114c0202, + 0x124c0202, 0x134c0202, 0x144c0202, 0x154c0202, 0x164c0202, 0x174c0202, 0x184c0202, 0x194c0202, + 0x1a4c0202, 0x1b4c0202, 0x1c4c0202, 0x1d4c0202, 0x1e4c0202, 0x1f4c0202, 0x204c0202, 0x214c0202, + 0x224c0202, 0x234c0202, 0x244c0202, 0x254c0202, 0x264c0202, 0x274c0202, 0x284c0202, 0x294c0202, + 0x2a4c0202, 0x2b4c0202, 0x464c0202, 0x474c0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x2c4c0202, 0x2d4c0202, 0x2e4c0202, 0x2f4c0202, 0x304c0202, 0x314c0202, 0x324c0202, 0x334c0202, + 0x344c0202, 0x354c0202, 0x364c0202, 0x374c0202, 0x384c0202, 0x394c0202, 0x3a4c0202, 0x3b4c0202, + 0x3c4c0202, 0x3d4c0202, 0x3e4c0202, 0x3f4c0202, 0x404c0202, 0x414c0202, 0x424c0202, 0x434c0202, + 0x444c0202, 0x454c0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x030d1a02, 0x1a0d1a02, 0x1c0d1a02, 0x1e0d1a02, 0x200d1a02, 0x220d1a02, 0x240d1a02, 0x260d1a02, + 0x280d1a02, 0x2a0d1a02, 0x1a0d2802, 0x00000000, 0x00000000, 0x00000000, 0x78070202, 0x79070202, + 0xc8430202, 0xc9430202, 0xca430202, 0xcb430202, 0xcc430202, 0xcd430202, 0xce430202, 0xcf430202, + 0xd0430202, 0xd1430202, 0xd2430202, 0xd3430202, 0xd4430202, 0xd5430202, 0xd6430202, 0xd7430202, + 0xd8430202, 0xd9430202, 0xda430202, 0xdb430202, 0xdc430202, 0xdd430202, 0xde430202, 0xdf430202, + 0xe0430202, 0xe1430202, 0xe2430202, 0xe3430202, 0xe4430202, 0xe5430202, 0xe6430202, 0xe7430202, + 0x644b0202, 0x654b0202, 0x664b0202, 0x674b0202, 0x684b0202, 0x694b0202, 0x6a4b0202, 0x6b4b0202, + 0x6c4b0202, 0x6d4b0202, 0x6e4b0202, 0x6f4b0202, 0x704b0202, 0x714b0202, 0x724b0202, 0x734b0202, + 0x744b0202, 0x754b0202, 0x764b0202, 0x774b0202, 0x784b0202, 0x794b0202, 0x7a4b0202, 0x7b4b0202, + 0x7c4b0202, 0x7d4b0202, 0x7e4b0202, 0x7f4b0202, 0x00000000, 0x00000000, 0x804b0202, 0x814b0202, + 0x03640202, 0x04640202, 0x05640202, 0x06640202, 0x07640202, 0x08640202, 0x09640202, 0x0a640202, + 0x0b640202, 0x0c640202, 0x0d640202, 0x0e640202, 0x0f640202, 0x10640202, 0x11640202, 0x12640202, + 0x13640202, 0x14640202, 0x15640202, 0x16640202, 0x17640202, 0x18640202, 0x19640202, 0x1a640202, + 0x1b640202, 0x1c640202, 0x1d640202, 0x1e640202, 0x1f640202, 0x20640202, 0x21640202, 0x22640202, + 0x23640202, 0x24640202, 0x25640202, 0x26640202, 0x27640202, 0x28640202, 0x29640202, 0x2a640202, + 0x2b640202, 0x2c640202, 0x2d640202, 0x2e640202, 0x2f640202, 0x38640202, 0x39640202, 0x3a640202, + 0x3b640202, 0x3c640202, 0x3d640202, 0x30640202, 0x29640203, 0x32640202, 0x33640202, 0x34640202, + 0x09640203, 0x09640203, 0x1e640203, 0x1e640203, 0x35640202, 0x36640202, 0x37640202, 0x00000000, + 0x4f640202, 0x3e640202, 0x40640202, 0x41640202, 0x41640203, 0x42640202, 0x43640202, 0x44640202, + 0x45640202, 0x46640202, 0x47640202, 0x31640202, 0x3f640202, 0x4e640202, 0x48640202, 0x49640202, + 0x4b640202, 0x4c640202, 0x4d640202, 0x4a640202, 0x00010300, 0x00010400, 0x00010500, 0x00010600, + 0x00010700, 0x00010800, 0x00010900, 0x00010a00, 0x00010b00, 0x00000000, 0x00000000, 0x00010c00, + 0x030d2702, 0x1a0d2902, 0x1c0d2802, 0x1e0d2802, 0x200d2602, 0x220d2602, 0x240d2702, 0x260d2602, + 0x280d2602, 0x2a0d2602, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x030d2802, 0x1a0d2a02, 0x1c0d2902, 0x1e0d2902, 0x200d2702, 0x220d2702, 0x240d2802, 0x260d2702, + 0x280d2702, 0x2a0d2702, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xe0070202, 0xe1070202, 0xe2070202, 0xe3070202, 0xe4070202, 0xe5070202, 0xe6070202, 0x02640202, + 0xdc070202, 0xdd070202, 0xde070202, 0xdf070202, 0xe7070202, 0xe8070202, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x64540202, 0x66540202, 0x68540202, 0x6a540202, 0x6c540202, 0x6e540202, 0x00000000, 0x72540202, + 0x00000000, 0x76540202, 0x00000000, 0x7a540202, 0x00000000, 0x7e540202, 0x00000000, 0x82540202, + 0x84540202, 0x86540202, 0x00000000, 0x8a540202, 0x8c540202, 0x8e540202, 0x90540202, 0x92540202, + 0x94540202, 0x96540202, 0x98540202, 0x9a540202, 0x9c540202, 0x9e540202, 0xa0540202, 0xa2540202, + 0xa4540202, 0xa6540202, 0xa8540202, 0xaa540202, 0xac540202, 0xae540202, 0xb0540202, 0xb2540202, + 0xb4540202, 0xb6540202, 0xb8540202, 0xba540202, 0xbc540202, 0xbe540202, 0xc0540202, 0xc2540202, + 0xc4540202, 0xc6540202, 0xc8540202, 0xca540202, 0xcc540202, 0xce540202, 0xd0540202, 0xd2540202, + 0xd4540202, 0xd6540202, 0xd8540202, 0x00000000, 0xdc540202, 0x00000000, 0xe0540202, 0xe2540202, + 0x00000000, 0x00000000, 0xe8540202, 0x00000000, 0xec540202, 0xee540202, 0xf0540202, 0xf2540202, + 0xf4540202, 0xf6540202, 0xf8540202, 0xfa540202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x030d1c02, 0x1a0d1c02, 0x1c0d1c02, 0x1e0d1c02, 0x200d1c02, 0x220d1c02, 0x240d1c02, 0x260d1c02, + 0x280d1c02, 0x2a0d1c02, 0xf6070202, 0xf7070202, 0xf8070202, 0xf9070202, 0xfa070202, 0xfb070202, + 0xfc070202, 0xfb0c0202, 0xfb0c0402, 0xfb0c0602, 0xfb0c0802, 0xfb0c0a02, 0xfb0c0c02, 0xfb0c0e02, + 0xfb0c1002, 0xfb0c1202, 0xfb0c1402, 0x0001bf00, 0x0001c000, 0x0001c100, 0x0001c200, 0x0001c300, + 0x0001c400, 0x0001c500, 0x0001c600, 0x0001c700, 0xfb0c1602, 0xfb0c1802, 0xfb0c1a02, 0xfb0c1c02, + 0xfb0c1e02, 0xfb0c2002, 0xfb0c2202, 0xfb0c2402, 0xfb0c2602, 0x00000000, 0x00000000, 0x00000000, + 0x025b0202, 0x035b0202, 0x045b0202, 0x0c5b0202, 0x0d5b0202, 0x0e5b0202, 0x0f5b0202, 0x105b0202, + 0x115b0202, 0x125b0202, 0x135b0202, 0x155b0202, 0x165b0202, 0x175b0202, 0x185b0202, 0x195b0202, + 0x1a5b0202, 0x1b5b0202, 0x1c5b0202, 0x1d5b0202, 0x1e5b0202, 0x1f5b0202, 0x205b0202, 0x215b0202, + 0x225b0202, 0x235b0202, 0x245b0202, 0x265b0202, 0x285b0202, 0x2a5b0202, 0x2b5b0202, 0x2c5b0202, + 0x2e5b0202, 0x255b0202, 0x275b0202, 0x295b0202, 0x2f5b0202, 0x305b0202, 0x315b0202, 0x325b0202, + 0x335b0202, 0x345b0202, 0x355b0202, 0x00000000, 0x00000000, 0x00000000, 0x145b0202, 0x2d5b0202, + 0x030d1e02, 0x1a0d1e02, 0x1c0d1e02, 0x1e0d1e02, 0x200d1e02, 0x220d1e02, 0x240d1e02, 0x260d1e02, + 0x280d1e02, 0x2a0d1e02, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x026b0202, 0x026b0203, 0x036b0202, 0x036b0203, 0x036b0203, 0x046b0202, 0x046b0203, 0x056b0202, + 0x056b0203, 0x066b0202, 0x066b0203, 0x076b0202, 0x076b0203, 0x076b0203, 0x086b0202, 0x086b0203, + 0x096b0202, 0x0a6b0202, 0x0b6b0202, 0x0b6b0203, 0x0c6b0202, 0x0c6b0203, 0x0d6b0202, 0x0d6b0203, + 0x0e6b0202, 0x0e6b0203, 0x0e6b0203, 0x0f6b0202, 0x0f6b0203, 0x106b0202, 0x116b0202, 0x116b0203, + 0x126b0202, 0x136b0202, 0x146b0202, 0x156b0202, 0x166b0202, 0x176b0202, 0x04430202, 0x186b0202, + 0x186b0203, 0x196b0202, 0x1a6b0202, 0x1a6b0203, 0x1b6b0202, 0x1b6b0203, 0x1c6b0202, 0x1c6b0203, + 0x1d6b0202, 0x1e6b0202, 0x1f6b0202, 0x206b0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xfb0c2702, 0xfb0c2802, 0xfb0c2902, 0xfb0c2a02, + 0x025c0202, 0x035c0202, 0x045c0202, 0x055c0202, 0x065c0202, 0x075c0202, 0x085c0202, 0x095c0202, + 0x0a5c0202, 0x0b5c0202, 0x0f5c0202, 0x105c0202, 0x115c0202, 0x125c0202, 0x135c0202, 0x145c0202, + 0x155c0202, 0x165c0202, 0x175c0202, 0x185c0202, 0x195c0202, 0x1a5c0202, 0x1b5c0202, 0x1c5c0202, + 0x1d5c0202, 0x1e5c0202, 0x1f5c0202, 0x215c0202, 0x235c0202, 0x245c0202, 0x255c0202, 0x265c0202, + 0x275c0202, 0x285c0202, 0x295c0202, 0x2a5c0202, 0x205c0202, 0x225c0202, 0x2c5c0202, 0x2d5c0202, + 0x2e5c0202, 0x2f5c0202, 0x305c0202, 0x315c0202, 0x325c0202, 0x335c0202, 0x345c0202, 0x355c0202, + 0x365c0202, 0x375c0202, 0x385c0202, 0x395c0202, 0x3a5c0202, 0x3b5c0202, 0x2b5c0202, 0x00010300, + 0x00000000, 0x00000000, 0x00000000, 0xe2070202, 0xe3070202, 0xe4070202, 0xe5070202, 0xe6070202, + 0x030d1f02, 0x1a0d1f02, 0x1c0d1f02, 0x1e0d1f02, 0x200d1f02, 0x220d1f02, 0x240d1f02, 0x260d1f02, + 0x280d1f02, 0x2a0d1f02, 0x00000000, 0x00000000, 0x00000000, 0x0c5c0202, 0x0d5c0202, 0x0e5c0202, + 0x030d2002, 0x1a0d2002, 0x1c0d2002, 0x1e0d2002, 0x200d2002, 0x220d2002, 0x240d2002, 0x260d2002, + 0x280d2002, 0x2a0d2002, 0x025d0202, 0x035d0202, 0x045d0202, 0x055d0202, 0x065d0202, 0x075d0202, + 0x085d0202, 0x095d0202, 0x0a5d0202, 0x0b5d0202, 0x0c5d0202, 0x0d5d0202, 0x0e5d0202, 0x0f5d0202, + 0x105d0202, 0x115d0202, 0x125d0202, 0x135d0202, 0x145d0202, 0x155d0202, 0x165d0202, 0x175d0202, + 0x185d0202, 0x195d0202, 0x1a5d0202, 0x1b5d0202, 0x1c5d0202, 0x1d5d0202, 0x1e5d0202, 0x1f5d0202, + 0x205d0202, 0x215d0202, 0x225d0202, 0x235d0202, 0x245d0202, 0x255d0202, 0xe7070202, 0xe8070202, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xff070202, 0xff070202, 0xff070202, 0xff070202, 0xff070202, 0xff070202, 0xff070202, 0xff070202, + 0xff070202, 0xff070202, 0xff070202, 0xff070202, 0xff070202, 0xff070202, 0xff070202, 0xff070202, + 0xff070202, 0xff070202, 0xff070202, 0xff070202, 0xff070202, 0xff070202, 0xff070202, 0xff070202, + 0xff070202, 0xfd320202, 0xfd320203, 0xfd320203, 0xfd320203, 0x06320202, 0xfd320203, 0xfd320203, + 0xfd320203, 0xfd320203, 0x08320202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x020e0216, 0x00000000, 0x00000000, 0x090e1e16, 0x0a0e0216, 0x1a0e0216, 0x1a0e6816, 0x210e0216, + 0x220e7d02, 0x320e0a02, 0x350e0216, 0x360e0216, 0x480e1f16, 0x510e0216, 0x700e0a16, 0x7c0e0216, + 0x0a0e7a16, 0x7c0e0a02, 0x7c0e0c02, 0x7c0e0d02, 0x7d0eaa02, 0x7c0edc16, 0x7c0ee602, 0x7c0ee702, + 0x7e0e0216, 0x8a0e0a16, 0x8a0e7b16, 0x990e0216, 0x9f0e0216, 0xa00e0c02, 0xa00e0f02, 0x510ee602, + 0xa20e0216, 0xa40e0216, 0xa90e0216, 0xac0e0216, 0x920e0c12, 0x030e0e02, 0x060f0216, 0x160f0216, + 0x220f0216, 0x240f0216, 0x300f0216, 0x32100216, 0x020e021a, 0x00000000, 0x090e021a, 0x090e1e1a, + 0x1a0e021a, 0x210e021a, 0x210e7d1a, 0x250e021a, 0x2c0e021a, 0x320e021a, 0x350e021a, 0x360e021a, + 0x480e021a, 0x510e021a, 0x700e021a, 0x700e0a1a, 0x7c0e021a, 0x7d0e021a, 0x7e0e021a, 0x8a0e021a, + 0x990e021a, 0x9f0e021a, 0xa40e021a, 0x020e020a, 0x020e030a, 0x020f020a, 0x00000000, 0x090e020a, + 0x1a0e020a, 0x210e020a, 0x210e7e0a, 0x220e020a, 0x220e7d0a, 0x250e020a, 0x320e0a0a, 0x360e020a, + 0x510e020a, 0x740e020a, 0x7c0e020a, 0x0a0e7a0a, 0x7c0ee60a, 0x7c0ee70a, 0x7e0e020a, 0x990e020a, + 0x9f0e020a, 0xa00e0c0a, 0x510e7b0a, 0xa20e020a, 0x030e0e0a, 0x040f020a, 0x060f050a, 0x080f020a, + 0x2c0f020a, 0x2e0f020a, 0x320e0204, 0x8a0e0204, 0x9f0e0204, 0xa20e0204, 0x040f0204, 0x060f0204, + 0x240f0204, 0x2c0f0204, 0x2e0f0204, 0xa10e0202, 0x090e1902, 0x1a0e1902, 0x230e1902, 0x510e1902, + 0x700e1a02, 0x7e0e1902, 0x8a0e1902, 0x8a0e1f02, 0x910e1902, 0x990e1902, 0xa90e1902, 0x250e0a02, + 0x3a10020a, 0x260e0a02, 0x9b0e0a02, 0x320e1e16, 0x320e9402, 0x7e0e1b02, 0x9f0e1e16, 0x9f0e9402, + 0x090e5602, 0x1a0e5602, 0x230e5602, 0x250e5602, 0x360e5602, 0x480e5602, 0x510e5602, 0x700e5602, + 0x7e0e5602, 0x8a0e5602, 0x910e5602, 0x910e8c02, 0xa20e5602, 0xa60e5602, 0xa90e5602, 0x020e5702, + 0x020e7e02, 0x1a0e5902, 0x210e5902, 0x220e5902, 0x220e8102, 0x210ed702, 0x320e5902, 0x0a0e7b02, + 0x910e9102, 0x9f0e5702, 0xac0e5902, 0x020e7d0a, 0x0a0e020a, 0x0a0e7c0a, 0x1a0e680a, 0x220e800a, + 0x230e020a, 0x350e1e0a, 0x250e7d0a, 0x2c0e7c0a, 0x320e1e0a, 0x320e7b0a, 0x320e021e, 0x320e1e1e, + 0x350e7b0a, 0x480e590a, 0x480e560a, 0x480e021e, 0x510e430a, 0x510e7c0a, 0x700e430a, 0x700e590a, + 0x700e021e, 0x7c0e200a, 0x7e0e7b0a, 0x910e430a, 0x910e7c0a, 0x990e570a, 0x9f0e1e0a, 0x9f0e7b0a, + 0x9f0e021e, 0xa20e7b0a, 0xa20e7c0a, 0xa90e020a, 0xa90e590a, 0xa90e7e0a, 0xac0e020a, 0x990e8c0a, + 0x00017a00, 0x00017b00, 0x00017c00, 0x00017d00, 0x00012100, 0x00012200, 0x00012200, 0x00012100, + 0x00012600, 0x00012500, 0x0001ff00, 0x00012700, 0x00012700, 0x00012800, 0x00012900, 0x00012a00, + 0x00012b00, 0x00012c00, 0xdf0e0302, 0x020e5b02, 0x00000000, 0x00000000, 0x00000000, 0x0a0e1d02, + 0x1a0ece02, 0x1a0e6902, 0x250e0302, 0x250e0316, 0x360e0302, 0x480e0302, 0x480e0316, 0x510e0316, + 0x700e0302, 0x700e0316, 0x8a0e0316, 0x8a0e8402, 0x910e0302, 0x970e0302, 0xa90e0302, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00012b00, 0x00012b00, 0x0001fd00, 0x0001fe00, + 0x020e5a12, 0x020e5a02, 0x090e1012, 0x090e1002, 0x090e5812, 0x090e5802, 0x090e6412, 0x090e6402, + 0x0a0e2812, 0x0a0e2802, 0x1a0e1012, 0x1a0e1002, 0x1a0e5812, 0x1a0e5802, 0x1a0e6412, 0x1a0e6402, + 0x1a0e1c12, 0x1a0e1c02, 0x1a0e6012, 0x1a0e6002, 0x210e2412, 0x210e2402, 0x210e2312, 0x210e2302, + 0x210e6012, 0x210e6002, 0x210e6312, 0x210e6302, 0x210e2f12, 0x210e2f02, 0x230e1012, 0x230e1002, + 0x250e1712, 0x250e1702, 0x2c0e1012, 0x2c0e1002, 0x2c0e5812, 0x2c0e5802, 0x2c0e1312, 0x2c0e1302, + 0x2c0e1c12, 0x2c0e1c02, 0x2c0e6112, 0x2c0e6102, 0x320e6312, 0x320e6302, 0x320e1f12, 0x320e1f02, + 0x360e0e12, 0x360e0e02, 0x360e5812, 0x360e5802, 0x360e6412, 0x360e6402, 0x480e5812, 0x480e5802, + 0x480e6d12, 0x480e6d02, 0x480e6412, 0x480e6402, 0x480e6012, 0x480e6002, 0x510e0e12, 0x510e0e02, + 0x510e1012, 0x510e1002, 0x510e5812, 0x510e5802, 0x700e1012, 0x700e1002, 0x700e5812, 0x700e5802, + 0x700e6412, 0x700e6402, 0x700e6012, 0x700e6002, 0x7c0e2512, 0x7c0e2502, 0x7c0e2a12, 0x7c0e2a02, + 0x7c0e2412, 0x7c0e2402, 0x7c0e2312, 0x7c0e2302, 0x7e0e0e12, 0x7e0e0e02, 0x7e0e1012, 0x7e0e1002, + 0x8a0e1012, 0x8a0e1002, 0x8a0e5812, 0x8a0e5802, 0x8a0e6d12, 0x8a0e6d02, 0x8a0e6412, 0x8a0e6402, + 0x910e1012, 0x910e1002, 0x910e5812, 0x910e5802, 0x910e1c12, 0x910e1c02, 0x910e2212, 0x910e2202, + 0x910e6612, 0x910e6602, 0x990e1012, 0x990e1002, 0x990e5812, 0x990e5802, 0x990e6412, 0x990e6402, + 0x990e6012, 0x990e6002, 0x9f0e5912, 0x9f0e5902, 0x9f0e6312, 0x9f0e6302, 0x9f0e6012, 0x9f0e6002, + 0x9f0e2512, 0x9f0e2502, 0x9f0e2812, 0x9f0e2802, 0xa20e1912, 0xa20e1902, 0xa20e5812, 0xa20e5802, + 0xa40e0f12, 0xa40e0f02, 0xa40e0e12, 0xa40e0e02, 0xa40e1312, 0xa40e1302, 0xa40e1012, 0xa40e1002, + 0xa40e5812, 0xa40e5802, 0xa60e1012, 0xa60e1002, 0xa60e1312, 0xa60e1302, 0xa70e1012, 0xa70e1002, + 0xa90e1212, 0xa90e1202, 0xa90e5812, 0xa90e5802, 0xa90e6412, 0xa90e6402, 0x2c0e6402, 0x990e1302, + 0xa40e1a02, 0xa70e1a02, 0x020e6902, 0x960e1002, 0x960e5902, 0x960e5a02, 0x00000000, 0x200e0202, + 0x020e5812, 0x020e5802, 0x020e4112, 0x020e4102, 0x020e1e12, 0x020e1e02, 0x020e1f12, 0x020e1f02, + 0x020e5112, 0x020e5102, 0x020e2912, 0x020e2902, 0x020e6812, 0x020e6802, 0x020e2112, 0x020e2102, + 0x020e2212, 0x020e2202, 0x020e5412, 0x020e5402, 0x020e2c12, 0x020e2c02, 0x020e6b12, 0x020e6b02, + 0x210e5812, 0x210e5802, 0x210e4112, 0x210e4102, 0x210e1912, 0x210e1902, 0x210e1e12, 0x210e1e02, + 0x210e1f12, 0x210e1f02, 0x210e5112, 0x210e5102, 0x210e2912, 0x210e2902, 0x210e6812, 0x210e6802, + 0x320e4112, 0x320e4102, 0x320e5812, 0x320e5802, 0x7c0e5812, 0x7c0e5802, 0x7c0e4112, 0x7c0e4102, + 0x7c0e1e12, 0x7c0e1e02, 0x7c0e1f12, 0x7c0e1f02, 0x7c0e5112, 0x7c0e5102, 0x7c0e2912, 0x7c0e2902, + 0x7c0e6812, 0x7c0e6802, 0x7c0e5c12, 0x7c0e5c02, 0x7c0e5d12, 0x7c0e5d02, 0x7c0e8f12, 0x7c0e8f02, + 0x7c0e6712, 0x7c0e6702, 0x7c0ea612, 0x7c0ea602, 0x9f0e5812, 0x9f0e5802, 0x9f0e4112, 0x9f0e4102, + 0x9f0e5c12, 0x9f0e5c02, 0x9f0e5d12, 0x9f0e5d02, 0x9f0e8f12, 0x9f0e8f02, 0x9f0e6712, 0x9f0e6702, + 0x9f0ea612, 0x9f0ea602, 0xa70e0f12, 0xa70e0f02, 0xa70e5812, 0xa70e5802, 0xa70e4112, 0xa70e4102, + 0xa70e1912, 0xa70e1902, 0x00000000, 0x00000000, 0xa20e7f12, 0xa20e7f02, 0xa70e5912, 0xa70e5902, + 0x020f4802, 0x020f4902, 0x020f5502, 0x020f5602, 0x020f5402, 0x020f5502, 0x020fd502, 0x020fd602, + 0x020f4812, 0x020f4912, 0x020f5512, 0x020f5612, 0x020f5412, 0x020f5512, 0x020fd512, 0x020fd612, + 0x0a0f4802, 0x0a0f4902, 0x0a0f5502, 0x0a0f5602, 0x0a0f5402, 0x0a0f5502, 0x00000000, 0x00000000, + 0x0a0f4812, 0x0a0f4912, 0x0a0f5512, 0x0a0f5612, 0x0a0f5412, 0x0a0f5512, 0x00000000, 0x00000000, + 0x0e0f4802, 0x0e0f4902, 0x0e0f5502, 0x0e0f5602, 0x0e0f5402, 0x0e0f5502, 0x0e0fd502, 0x0e0fd602, + 0x0e0f4812, 0x0e0f4912, 0x0e0f5512, 0x0e0f5612, 0x0e0f5412, 0x0e0f5512, 0x0e0fd512, 0x0e0fd612, + 0x120f4802, 0x120f4902, 0x120f5502, 0x120f5602, 0x120f5402, 0x120f5502, 0x120fd502, 0x120fd602, + 0x120f4812, 0x120f4912, 0x120f5512, 0x120f5612, 0x120f5412, 0x120f5512, 0x120fd512, 0x120fd612, + 0x200f4802, 0x200f4902, 0x200f5502, 0x200f5602, 0x200f5402, 0x200f5502, 0x00000000, 0x00000000, + 0x200f4812, 0x200f4912, 0x200f5512, 0x200f5612, 0x200f5412, 0x200f5512, 0x00000000, 0x00000000, + 0x2a0f4802, 0x2a0f4902, 0x2a0f5502, 0x2a0f5602, 0x2a0f5402, 0x2a0f5502, 0x2a0fd502, 0x2a0fd602, + 0x00000000, 0x2a0f4912, 0x00000000, 0x2a0f5612, 0x00000000, 0x2a0f5512, 0x00000000, 0x2a0fd612, + 0x320f4802, 0x320f4902, 0x320f5502, 0x320f5602, 0x320f5402, 0x320f5502, 0x320fd502, 0x320fd602, + 0x320f4812, 0x320f4912, 0x320f5512, 0x320f5612, 0x320f5412, 0x320f5512, 0x320fd512, 0x320fd612, + 0x020f0f02, 0x00000000, 0x0a0f0f02, 0x00000000, 0x0e0f0f02, 0x00000000, 0x120f0f02, 0x00000000, + 0x200f0f02, 0x00000000, 0x2a0f0f02, 0x00000000, 0x320f0f02, 0x00000000, 0x00000000, 0x00000000, + 0x020fd802, 0x020fd902, 0x020fe502, 0x020fe602, 0x020fe402, 0x020fe502, 0x020f6502, 0x020f6602, + 0x020fd812, 0x020fd912, 0x020fe512, 0x020fe612, 0x020fe412, 0x020fe512, 0x020f6512, 0x020f6612, + 0x0e0fd802, 0x0e0fd902, 0x0e0fe502, 0x0e0fe602, 0x0e0fe402, 0x0e0fe502, 0x0e0f6502, 0x0e0f6602, + 0x0e0fd812, 0x0e0fd912, 0x0e0fe512, 0x0e0fe612, 0x0e0fe412, 0x0e0fe512, 0x0e0f6512, 0x0e0f6612, + 0x320fd802, 0x320fd902, 0x320fe502, 0x320fe602, 0x320fe402, 0x320fe502, 0x320f6502, 0x320f6602, + 0x320fd812, 0x320fd912, 0x320fe512, 0x320fe612, 0x320fe412, 0x320fe512, 0x320f6512, 0x320f6612, + 0x020f1502, 0x020f1702, 0x020f9f02, 0x020f9202, 0x020f9e02, 0x00000000, 0x020f8f02, 0x020f1f02, + 0x020f1512, 0x020f1712, 0x020f0f12, 0x00000000, 0x020f9212, 0xbc070202, 0x00000000, 0xbd070202, + 0xbe070202, 0x53078f02, 0x0e0f9f02, 0x0e0f9202, 0x0e0f9e02, 0x00000000, 0x0e0f8f02, 0x0e0f1f02, + 0x0a0f0f12, 0x00000000, 0x0e0f0f12, 0x00000000, 0x0e0f9212, 0xbd070f02, 0xbd070e02, 0xbd078f02, + 0x120f1502, 0x120f1702, 0x120f2002, 0x00000000, 0x00000000, 0x00000000, 0x120f8f02, 0x120fa002, + 0x120f1512, 0x120f1712, 0x120f0f12, 0x00000000, 0x00000000, 0xc7070f02, 0xc7070e02, 0xc7078f02, + 0x2a0f1502, 0x2a0f1702, 0x2a0f2002, 0x00000000, 0x240f4802, 0x240f4902, 0x2a0f8f02, 0x2a0fa002, + 0x2a0f1512, 0x2a0f1712, 0x2a0f0f12, 0x00000000, 0x240f4912, 0x53070f02, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x320f9f02, 0x320f9202, 0x320f9e02, 0x00000000, 0x320f8f02, 0x320f1f02, + 0x200f0f12, 0x00000000, 0x320f0f12, 0x00000000, 0x320f9212, 0x00000000, 0xc7070202, 0x00000000, + 0x00000000, 0x00000000, 0x0c070202, 0x0d070202, 0x0e070202, 0x0f070202, 0x10070202, 0x11070202, + 0x12070202, 0x13070202, 0x14070202, 0x15070202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x84060202, 0x85060202, 0x88060202, 0x89060202, 0x90060202, 0x92060202, 0x77070202, 0x78070202, + 0x79070202, 0x7a070202, 0x7b070202, 0x7c070202, 0x7d070202, 0x7e070202, 0x7f070202, 0x80070202, + 0x250b0202, 0x260b0202, 0x270b0202, 0x280b0202, 0x00000000, 0x0f0a0202, 0x100a0202, 0x86060202, + 0x17070202, 0x18070202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x02070a02, + 0x2c0b0c02, 0x2c0b0e02, 0x81070202, 0x81071402, 0x81072802, 0x84070202, 0x81071902, 0x81072d02, + 0x87070202, 0x88070202, 0x89070202, 0x2e0b0202, 0x1c071402, 0x8b070202, 0x8c070202, 0x8d070202, + 0x2f0b0202, 0x300b0202, 0x310b0202, 0x87060202, 0x07080202, 0x3f071c02, 0x42071c02, 0x3c076402, + 0x3c07c802, 0x1c07c802, 0x87070202, 0x25070202, 0x24070202, 0x1d070202, 0x1e070202, 0x23070202, + 0x22070202, 0x2d076402, 0x21070202, 0x88070202, 0x20070202, 0x1a071502, 0x1a071f02, 0x1f070202, + 0x1a072902, 0x1a073302, 0x1a073d02, 0x1a074702, 0x020c0202, 0x030c0202, 0x040c0202, 0x02070202, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x030d020e, 0x320e020e, 0x00000000, 0x00000000, 0x200d020e, 0x220d020e, 0x240d020e, 0x260d020e, + 0x280d020e, 0x2a0d020e, 0x0308020e, 0x8306020e, 0x1208020e, 0x2707020e, 0x2a07020e, 0x700e020e, + 0x030d0204, 0x1a0d0204, 0x1c0d0204, 0x1e0d0204, 0x200d0204, 0x220d0204, 0x240d0204, 0x260d0204, + 0x280d0204, 0x2a0d0204, 0x03080204, 0x83060204, 0x12080204, 0x27070204, 0x2a070204, 0x00000000, + 0x020e0204, 0x210e0204, 0x7c0e0204, 0xa60e0204, 0x210e7e04, 0x2c0e020b, 0x360e020b, 0x480e020b, + 0x510e020b, 0x700e020f, 0x7e0e020b, 0x910e020b, 0x990e020b, 0x00000000, 0x00000000, 0x00000000, + 0x9d070202, 0xab070202, 0xa8070202, 0x9e070202, 0x9f070202, 0xa0070202, 0xa1070202, 0xa2070202, + 0xa3070202, 0xa4070202, 0xb6070202, 0xb7070202, 0xa9070202, 0xa0070202, 0xa7070202, 0xa5070202, + 0xa6070202, 0x9b070202, 0xb2070202, 0xb3070202, 0xb4070202, 0xb5070202, 0x00000000, 0x00000000, + 0x00000000, 0xbf070202, 0xc0070202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x0001dd00, 0x0001de00, 0x0001df00, 0x0001e000, 0x0001e100, 0x0001e200, 0x0001e300, 0x0001e400, + 0x0001e500, 0x0001e600, 0x0001e700, 0x0001e800, 0x0001e900, 0x0001ec00, 0x0001ed00, 0x0001ee00, + 0x0001ef00, 0x0001f000, 0x0001f100, 0x0001f200, 0x0001f300, 0x0001f400, 0x0001f500, 0x0001f600, + 0x0001f700, 0x0001f800, 0x0001f900, 0x00017e00, 0x00018b00, 0x00018c00, 0x00018d00, 0x00018e00, + 0x00018f00, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x050e0202, 0x060e0402, 0x0a0e0412, 0x0a0e0512, 0x130e021a, 0x180e0202, 0x190e0202, 0x220ec812, + 0x920e0a12, 0x230e0412, 0x250e0402, 0x2c0e0412, 0x2c0e0712, 0x2c0e0612, 0x2c0e0502, 0x2c0e6802, + 0x320e0512, 0x320e0612, 0x480e0412, 0x480e0402, 0x490e0202, 0x700e0412, 0x710e0212, 0xfa0a0202, + 0x7e0e0412, 0x7e0e0312, 0x890e0312, 0x8a0e0512, 0x8a0e0612, 0x8a0e0412, 0x8b0e0212, 0x8c0e0212, + 0x930e0212, 0x9a0e0212, 0x9c0e0212, 0xa30e0212, 0xa90e0412, 0xa90e6312, 0x00000000, 0x320f0312, + 0xa90e0512, 0x320f0512, 0x00000000, 0x00000000, 0x090e0412, 0x0a0e0612, 0x210e0502, 0x210e0402, + 0x210e0412, 0x230e0512, 0x230e0312, 0x510e0412, 0x7c0e0402, 0x02280206, 0x03280206, 0x04280206, + 0x05280206, 0x330ef002, 0x890e0812, 0x020b0202, 0x220f020a, 0x060f0502, 0x060f0512, 0x220f0512, + 0x210e0802, 0x250e0a12, 0x480e0c12, 0x480e0d12, 0xa70e0d12, 0x1a0e0412, 0x1a0e0402, 0x210e0602, + 0x320e0702, 0x350e0502, 0x4d0b0202, 0x0a070a02, 0x640c0202, 0x650c0202, 0x230e0302, 0xfd0c0202, + 0x0a0d0202, 0x080d0202, 0x070d0202, 0x0e0d0202, 0x140d0202, 0x0c0d0202, 0x100d0202, 0x120d0202, + 0x160d0202, 0x0b0d0202, 0x170d0202, 0x090d0202, 0x0f0d0202, 0x130d0202, 0x180d0202, 0xa60de602, + 0xab0de812, 0xac0de812, 0xad0de812, 0xae0de812, 0xaf0de812, 0xb00de812, 0xb10de812, 0xb20de812, + 0xb30de812, 0xb40de812, 0xb50de812, 0xb60de812, 0xb90de812, 0xbe0de812, 0xc30de812, 0xc80de812, + 0xab0de802, 0xac0de802, 0xad0de802, 0xae0de802, 0xaf0de802, 0xb00de802, 0xb10de802, 0xb20de802, + 0xb30de802, 0xb40de802, 0xb50de802, 0xb60de802, 0xb90de802, 0xbe0de802, 0xc30de802, 0xc80de802, + 0xc80de802, 0xcd0de812, 0xd20de812, 0xbe0de712, 0xbe0de702, 0x240d2502, 0x540d1502, 0xd30d0202, + 0xd70d0202, 0x030d2a02, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xdf090202, 0xd9090303, 0xdb090202, 0xdd090303, 0xe1090202, 0xe2090302, 0xe0090302, 0xda090302, + 0xdc090302, 0xde090302, 0xdf092002, 0xdb092002, 0xdf090502, 0xdb090502, 0xdf090602, 0xd9090402, + 0xdb090602, 0xdd090402, 0xdf090702, 0xdb090702, 0xdf090802, 0xd9090502, 0xdb090802, 0xdd090502, + 0xe2090402, 0xdf090902, 0xdb090902, 0xdf090a02, 0xdb090a02, 0xe1090402, 0xe1092002, 0xdd090602, + 0xdf090b02, 0xdb090b02, 0xdf090c02, 0xdb090c02, 0xdd090702, 0xdf090d02, 0xe4090302, 0xe3090302, + 0xe0090402, 0xe1090602, 0xe4090402, 0xe3090402, 0xdf090e02, 0xdf090f02, 0xd9090602, 0xd9090702, + 0xdb090d02, 0xdb090e02, 0xdd090802, 0xdd090902, 0xe1090702, 0xe2090602, 0xe1090802, 0xdf091002, + 0xd9090802, 0xdb090f02, 0xdd090a02, 0xe1090902, 0xe1090a02, 0xdf092f02, 0xe1092a02, 0xdb092f02, + 0xdf091102, 0xd9090902, 0xdb091102, 0xdd090b02, 0xe1090c02, 0xe2090502, 0xe0090502, 0xda090402, + 0xdc090402, 0xde090402, 0xdf091302, 0xdb091202, 0xdf091402, 0xdb091302, 0xd9090a02, 0xdd090c02, + 0xdf091502, 0xd9090b02, 0xdb091402, 0xdd090d02, 0xdf091602, 0xdb091502, 0xdf091702, 0xd9090c02, + 0xdb091602, 0xdd090e02, 0xd9090d02, 0xd9091c02, 0xd9092602, 0xd9093002, 0xd9096502, 0xd9097902, + 0xdb092a02, 0xe009d202, 0xdc09d202, 0xe2090c02, 0xdb093802, 0xdd09aa02, 0xdb093f02, 0xdf093302, + 0xdb094702, 0xdb09c902, 0xdf093d02, 0xdb095102, 0xdd09c902, 0xdf094702, 0xdb095b02, 0xdf095102, + 0x21080202, 0x22080202, 0x23080202, 0x24080202, 0x24082002, 0x26080202, 0x27080202, 0x28080202, + 0x29080202, 0x29082002, 0x2b080202, 0x2c080202, 0x2c082002, 0x2e080202, 0x2f080202, 0x30080202, + 0x31080202, 0x32080202, 0x83060202, 0x0c080202, 0x33080202, 0x08080202, 0x34080202, 0x09080202, + 0x0a080202, 0x0b080202, 0x35080202, 0x36080202, 0x37080202, 0x38080202, 0xff0d7f02, 0x39080202, + 0x3a080202, 0x3b080202, 0x3c080202, 0x3d080202, 0x3d082002, 0x3f080202, 0x3f082002, 0x41080202, + 0x42080202, 0x43080202, 0x44080202, 0x45080202, 0x130a1502, 0x130a2902, 0x48080202, 0x130a3d02, + 0x130a5102, 0x4b080202, 0x4c080202, 0x4d080202, 0x4e080202, 0x4f080202, 0x50080202, 0x51080202, + 0x52080202, 0x53080202, 0x54080202, 0x55080202, 0x56080202, 0x57080202, 0x58080202, 0x59080202, + 0x5a080202, 0x56082002, 0x5c080202, 0x5d080202, 0x5d082002, 0x5f080202, 0x60080202, 0x5f082002, + 0x62080202, 0x62082002, 0x64080202, 0x65080202, 0x66080202, 0x67080202, 0x68080202, 0x69080202, + 0x6a080202, 0x6b080202, 0x6c080202, 0x6d080202, 0x6e080202, 0x6f080202, 0x70080202, 0x71080202, + 0x72080202, 0x73080202, 0x74080202, 0x75080202, 0x76080202, 0x77080202, 0x78080202, 0x79080202, + 0x12082002, 0x7b080202, 0x7b082002, 0x7d080202, 0x7e080202, 0x7f080202, 0x80080202, 0x81080202, + 0x82080202, 0x83080202, 0x19080302, 0x1b080302, 0x84080202, 0x67082002, 0x0e082002, 0x14082002, + 0x7e082002, 0x7f082002, 0x8a080202, 0x8b080202, 0x8a082002, 0x8b082002, 0x8e080202, 0x8f080202, + 0x8e082002, 0x8f082002, 0x0f080202, 0x15080202, 0x92080202, 0x93080202, 0x94080202, 0x95080202, + 0x0f082002, 0x15082002, 0x98080202, 0x99080202, 0x98082002, 0x99082002, 0x9c080202, 0x9d080202, + 0x9c082002, 0x9d082002, 0xa0080202, 0xa1080202, 0xa2080202, 0xa3080202, 0xa4080202, 0xa5080202, + 0xa6080202, 0xa7080202, 0xa8080202, 0xa9080202, 0xaa080202, 0x0308ee02, 0x0408ee02, 0x0608ee02, + 0x0808ee02, 0x0b08ee02, 0x0a08ee02, 0x0908ee02, 0x1208ee02, 0x0508ee02, 0x0308ef02, 0x0408ef02, + 0x0608ef02, 0x0b08ef02, 0xab080202, 0xac080202, 0xad080202, 0xae080202, 0xaf080202, 0xb0080202, + 0xb1080202, 0xb2080202, 0xb3080202, 0xb4080202, 0xab082002, 0xb1082002, 0xb2082002, 0xb4082002, + 0x10080202, 0x16080202, 0xb9080202, 0xba080202, 0xbb080202, 0xbc080202, 0xbd080202, 0xbe080202, + 0xbf080202, 0xc0080202, 0xc1080202, 0xc2080202, 0xc3080202, 0xc4080202, 0xc5080202, 0xc6080202, + 0xc7080202, 0xc8080202, 0xc9080202, 0xca080202, 0xcb080202, 0xcc080202, 0xcd080202, 0xce080202, + 0xcf080202, 0xd2081f02, 0xd2082902, 0xd2080b02, 0xd2081502, 0xd4080202, 0xd5080202, 0xd6080202, + 0x98086402, 0x99086402, 0xd9080202, 0xda080202, 0xdb080202, 0xdc080202, 0xdd080202, 0xde080202, + 0xdf080202, 0xe0080202, 0xe1080202, 0xe2080202, 0xe3080202, 0xe4080202, 0xe5080202, 0xe6080202, + 0x92082002, 0x93082002, 0xa7082002, 0xa8082002, 0xeb080202, 0xec080202, 0xed080202, 0xee080202, + 0xef080202, 0xf0080202, 0xb9082002, 0xba082002, 0xbb082002, 0xbc082002, 0xf5080202, 0xf6080202, + 0xf7080202, 0xf8080202, 0x29081802, 0x29081602, 0x2b081602, 0x29081402, 0x29081202, 0x2b081202, + 0x29081002, 0x29080e02, 0xd0081502, 0xd0081f02, 0xd0082902, 0x86084702, 0x87085102, 0x88085b02, + 0x38093602, 0x38093702, 0x04090202, 0x05090202, 0x06090202, 0x07090202, 0x08090202, 0x09090202, + 0x0a090202, 0x0b090202, 0x0c090202, 0x0d090202, 0x0e090202, 0x0f090202, 0x10090202, 0x11090202, + 0x12090202, 0x13090202, 0x14090202, 0x15090202, 0x16090202, 0x17090202, 0x18090202, 0x19090202, + 0x1a090202, 0x1b090202, 0x1c090202, 0x1d090202, 0x1e090202, 0x1f090202, 0x20090202, 0x21090202, + 0x22090202, 0x23090202, 0x24090202, 0x25090202, 0x26090202, 0x27090202, 0x28090202, 0x29090202, + 0x2a090202, 0x00000000, 0x00000000, 0x2d090202, 0x2e090202, 0x2f090202, 0x30090202, 0x31090202, + 0x32090202, 0x33090202, 0x34090202, 0x35090202, 0x36090202, 0x37090202, 0x38093802, 0x38093902, + 0x38093a02, 0x38093b02, 0x38093c02, 0x38093d02, 0x38093e02, 0x38093f02, 0x38094002, 0x38094102, + 0x38094202, 0x38094302, 0x38094402, 0x38094502, 0x38094602, 0x38094702, 0x38094802, 0x38094902, + 0x38094a02, 0x38094b02, 0x38094c02, 0x38094d02, 0x38094e02, 0x38094f02, 0x38095002, 0x38095102, + 0x38095202, 0x38095302, 0x38095402, 0x38095502, 0x38095602, 0x38095702, 0x38095802, 0x38095902, + 0x38095a02, 0x38095b02, 0x38095c02, 0x38095d02, 0x38095e02, 0x38095f02, 0x38096002, 0x38096102, + 0x38096202, 0x38096302, 0x38096402, 0x38096502, 0x38096602, 0x38096702, 0x38096802, 0x38096902, + 0x38096a02, 0x38096b02, 0x38096c02, 0x38096d02, 0x38096e02, 0x38096f02, 0x38097002, 0x38097102, + 0x38097202, 0x38097302, 0x38097402, 0x38097502, 0x38097602, 0x38097702, 0x38097802, 0x38097902, + 0x38097a02, 0x38097b02, 0x38097c02, 0x4e0b0202, 0x85090202, 0x4f0b0202, 0x500b0202, 0x510b0202, + 0x520b0202, 0x3e0b0b02, 0x3e0b0d02, 0x3f0b0202, 0x400b0202, 0x410b0202, 0x420b0202, 0x430b0202, + 0x440b0202, 0x530b0202, 0x540b0202, 0x86090202, 0x550b0202, 0x560b0202, 0x570b0202, 0x0c0b1502, + 0x0c0b1702, 0x0c0b1902, 0x0c0b1b02, 0x0c0b1d02, 0x580b0202, 0x38093502, 0x590b0202, 0x450b0202, + 0x460b0202, 0x470b0202, 0x480b0202, 0x0b076002, 0x0b076e02, 0x0b075a02, 0x0c076002, 0x0c076e02, + 0x0c075a02, 0x17076002, 0x17076e02, 0x17075a02, 0x19076002, 0x19076e02, 0x19075a02, 0x26070302, + 0x26070402, 0x26070502, 0x27070a02, 0x28070302, 0x28070402, 0x28070502, 0x5a0b0202, 0x5b0b0202, + 0x27071402, 0x27071e02, 0x490b1502, 0x490b1f02, 0x66070202, 0x68070202, 0x67070a02, 0x5c0b0202, + 0x4a0b0c02, 0x4a0b0e02, 0x0e0b1502, 0x0e0b1702, 0x0e0b1902, 0x0e0b1b02, 0x0d0b1502, 0x0d0b1702, + 0x0d0b1902, 0x0d0b1b02, 0x0d0b1d02, 0x0d0b1f02, 0x0d0b2102, 0x0d0b2302, 0x0d0b2502, 0x0d0b2702, + 0x0d0b2902, 0x0d0b2b02, 0x0d0b2d02, 0x0d0b2f02, 0x0d0b3102, 0x5d0b0202, 0x0f0b1502, 0x0f0b1702, + 0x5e0b0202, 0x650c0202, 0x660c0202, 0x670c0202, 0x680c0202, 0x690c0202, 0x6a0c0202, 0x6b0c0202, + 0x6c0c0202, 0x6d0c0202, 0x6e0c0202, 0x6f0c0202, 0xe2070202, 0xe3070202, 0xe4070202, 0xe5070202, + 0xe6070202, 0xe7070202, 0xe8070202, 0xe9070202, 0xea070202, 0xeb070202, 0xec070202, 0xed070202, + 0xed070302, 0xed070402, 0xed070502, 0xed070602, 0xed070702, 0xed070802, 0xed070902, 0xed070a02, + 0xed070b02, 0xed070c02, 0xed070d02, 0xed070e02, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xb60c0202, 0xb70c0202, 0xb80c0202, 0xb90c0202, 0xba0c0202, 0xbb0c0202, 0xbc0c0202, 0xbd0c0202, + 0xbe0c0202, 0xbf0c0202, 0xc00c0202, 0xc10c0202, 0xc20c0202, 0xc30c0202, 0xc40c0202, 0xc50c0202, + 0xc60c0202, 0xc70c0202, 0xc80c0202, 0xc90c0202, 0xca0c0202, 0xcb0c0202, 0xcc0c0202, 0xcd0c0202, + 0xce0c0202, 0xcf0c0202, 0xd00c0202, 0xd10c0202, 0xd20c0202, 0xd30c0202, 0xd40c0202, 0xd50c0202, + 0xd60c0202, 0xd70c0202, 0x19070202, 0x1a070202, 0xd80c0202, 0x4b0b1502, 0x4b0b1f02, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xee0a0202, 0xef0a0202, 0xf00a0202, 0xf10a0202, 0xf20a0202, 0xf30a0202, 0xf40a0202, 0xf50a0202, + 0xf60a0202, 0xf70a0202, 0xf80a0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x1a0d0206, 0x1c0d0206, 0x1e0d0206, 0x200d0206, 0x220d0206, 0x240d0206, 0x260d0206, 0x280d0206, + 0x2a0d0206, 0x2c0d0206, 0x2d0d0206, 0x2e0d0206, 0x2f0d0206, 0x300d0206, 0x310d0206, 0x320d0206, + 0x330d0206, 0x340d0206, 0x350d0206, 0x360d0206, 0x1a0de902, 0x1c0de902, 0x1e0de902, 0x200de902, + 0x220de902, 0x240de902, 0x260de902, 0x280de902, 0x2a0de902, 0x2c0de902, 0x2d0de902, 0x2e0de902, + 0x2f0de902, 0x300de902, 0x310de902, 0x320de902, 0x330de902, 0x340de902, 0x350de902, 0x360de902, + 0x1a0dea02, 0x1c0dea02, 0x1e0dea02, 0x200dea02, 0x220dea02, 0x240dea02, 0x260dea02, 0x280dea02, + 0x2a0dea02, 0x2c0dea02, 0x2d0dea02, 0x2e0dea02, 0x2f0dea02, 0x300dea02, 0x310dea02, 0x320dea02, + 0x330dea02, 0x340dea02, 0x350dea02, 0x360dea02, 0x020ef202, 0x090ef202, 0x0a0ef202, 0x1a0ef202, + 0x210ef202, 0x230ef202, 0x250ef202, 0x2c0ef202, 0x320ef202, 0x350ef202, 0x360ef202, 0x480ef202, + 0x510ef202, 0x700ef202, 0x7c0ef202, 0x7e0ef202, 0x890ef202, 0x8a0ef202, 0x910ef202, 0x990ef202, + 0x9f0ef202, 0xa20ef202, 0xa40ef202, 0xa60ef202, 0xa70ef202, 0xa90ef202, 0x020eee12, 0x090eee12, + 0x0a0eee12, 0x1a0eee12, 0x210eee12, 0x230eee12, 0x250eee12, 0x2c0eee12, 0x320eee12, 0x350eee12, + 0x360eee12, 0x480eee12, 0x510eee12, 0x700eee12, 0x7c0eee12, 0x7e0eee12, 0x890eee12, 0x8a0eee12, + 0x910eee12, 0x990eee12, 0x9f0eee12, 0xa20eee12, 0xa40eee12, 0xa60eee12, 0xa70eee12, 0xa90eee12, + 0x020eee02, 0x090eee02, 0x0a0eee02, 0x1a0eee02, 0x210eee02, 0x230eee02, 0x250eee02, 0x2c0eee02, + 0x320eee02, 0x350eee02, 0x360eee02, 0x480eee02, 0x510eee02, 0x700eee02, 0x7c0eee02, 0x7e0eee02, + 0x890eee02, 0x8a0eee02, 0x910eee02, 0x990eee02, 0x9f0eee02, 0xa20eee02, 0xa40eee02, 0xa60eee02, + 0xa70eee02, 0xa90eee02, 0x030d0206, 0x2d0d0214, 0x2e0d0214, 0x2f0d0214, 0x300d0214, 0x310d0214, + 0x320d0214, 0x330d0214, 0x340d0214, 0x350d0214, 0x360d0214, 0x1a0d0207, 0x1c0d0207, 0x1e0d0207, + 0x200d0207, 0x220d0207, 0x240d0207, 0x260d0207, 0x280d0207, 0x2a0d0207, 0x2c0d0207, 0x030d020a, + 0xe5090302, 0xe5090402, 0xe8090303, 0xe8090402, 0xe5090502, 0xe5090602, 0xe8090502, 0xe8090602, + 0xe5090702, 0xe5090802, 0xe8090702, 0xe8090802, 0xeb090302, 0xeb090402, 0xeb090502, 0xeb090602, + 0xec090302, 0xec090402, 0xec090502, 0xec090602, 0xed090302, 0xed090402, 0xed090502, 0xed090602, + 0xee090302, 0xee090402, 0xee090502, 0xee090602, 0xef090302, 0xef090402, 0xef090502, 0xef090602, + 0xef090702, 0xef090802, 0xef090902, 0xef090a02, 0xf0090302, 0xf0090402, 0xf0090502, 0xf0090602, + 0xf0090702, 0xf0090802, 0xf0090902, 0xf0090a02, 0xf1090302, 0xf1090402, 0xf1090502, 0xf1090602, + 0xf1090702, 0xf1090802, 0xf1090902, 0xf1090a02, 0xf2090302, 0xf2090402, 0xf2090502, 0xf2090602, + 0xf2090702, 0xf2090802, 0xf2090902, 0xf2090a02, 0xf3090302, 0xf3090402, 0xf3090502, 0xf3090602, + 0xf3090702, 0xf3090802, 0xf3090902, 0xf3090a02, 0xf3090b02, 0xf3090c02, 0xf3090d02, 0xf3090e02, + 0xf3090f02, 0xf3091002, 0xf3091102, 0xf3091202, 0xe5090902, 0xe5090a02, 0xe8090902, 0xe8090a02, + 0xe5090b02, 0xe8090b02, 0xeb090702, 0xeb090802, 0xeb090902, 0xec090702, 0xec090802, 0xec090902, + 0xed090702, 0xed090802, 0xed090902, 0xee090702, 0xee090802, 0xee090902, 0xef090b02, 0xef090c02, + 0xef090d02, 0xf0090b02, 0xf0090c02, 0xf0090d02, 0xf1090b02, 0xf1090c02, 0xf1090d02, 0xf2090b02, + 0xf2090c02, 0xf2090d02, 0xf3091302, 0xf3091402, 0xf3091502, 0xeb090a02, 0xec090a02, 0xee090a02, + 0xed090a02, 0xf4090302, 0xf5090302, 0xf6090302, 0xe6090302, 0xe9090302, 0xe7090302, 0xea090302, + 0xe6090402, 0xe9090402, 0xe7090402, 0xea090402, 0xe5090c02, 0xe8090c02, 0xe5090d02, 0xe8090d02, + 0xfa090302, 0xf7090302, 0xf8090302, 0xf9090302, 0xfa090402, 0xfb090302, 0xfc090302, 0xfd090302, + 0xfe090302, 0xfd090402, 0xfc090402, 0xfb090402, 0xfa090502, 0xf9090402, 0xf8090402, 0xf7090402, + 0xfa090602, 0xfe090402, 0xfe090502, 0xfe090602, 0xf7090502, 0xf7090602, 0x100b0c02, 0x100b0e02, + 0x100b1002, 0x100b1202, 0x100b1402, 0x100b1602, 0x100b1802, 0x100b1a02, 0x100b1c02, 0x100b1e02, + 0xbc090303, 0xbc090402, 0xbc090502, 0xbc090602, 0xbc090702, 0xbc090802, 0xbc090902, 0xbc090a02, + 0xbc090b02, 0xbc090c02, 0xbc090d02, 0xbc090e02, 0xbd090302, 0xbd090402, 0xbe090302, 0xbe090402, + 0xbf090302, 0xbf090402, 0xc0090302, 0xc0090402, 0xc0090502, 0xc0090602, 0xc1090302, 0xc1090402, + 0xc1090502, 0xc1090602, 0xc4090302, 0xc4090402, 0xc2090302, 0xc2090402, 0xc2090502, 0xc2090602, + 0xc3090302, 0xc3090402, 0xc3090502, 0xc3090602, 0xc5090302, 0xc5090402, 0xc6090302, 0xc6090402, + 0xc6090502, 0xc7090302, 0xc8090302, 0xc9090303, 0xc9090402, 0xc9090502, 0xc9090602, 0xc9090702, + 0xc9090802, 0xc9090902, 0xc9090a02, 0xc9090b02, 0xc9090c02, 0xc9090d02, 0xca090302, 0xcb090302, + 0xcc090302, 0xc9090e02, 0xcd090302, 0xce090302, 0xcf090302, 0xd0090302, 0xd1090302, 0xd2090302, + 0xd3090302, 0xd4090302, 0xd5090302, 0xd6090302, 0xd7090302, 0xd8090302, 0xcc090402, 0xbc090f02, + 0xbc091002, 0xbc091102, 0xbc091202, 0xbc091302, 0xc0090702, 0xc0090802, 0xc0090902, 0xc1090202, + 0x110b0c02, 0x110b0e02, 0x110b1002, 0x110b1202, 0x120b0c02, 0x120b0e02, 0x120b1002, 0x120b1202, + 0x130b0c02, 0x130b0e02, 0x130b1002, 0x140b1502, 0x140b1702, 0x140b1902, 0x140b1b02, 0x130b1202, + 0x2f0a0202, 0x300a0202, 0x310a0202, 0x320a0202, 0x330a0202, 0x350a0202, 0x340a0202, 0x360a0202, + 0x370a0202, 0x380a0202, 0x390a0202, 0x3a0a0202, 0x3b0a0202, 0x3c0a0202, 0x3d0a0202, 0x3e0a0202, + 0x3f0a0202, 0x400a0202, 0x410a0202, 0x420a0202, 0x040b0202, 0x050b0202, 0x060b0202, 0x070b0202, + 0x700c0202, 0x080b0202, 0xdf093c02, 0xdb094002, 0xdf093d02, 0xd9093c02, 0xdb093e02, 0xdd093c02, + 0x430a0202, 0x440a0202, 0x450a0202, 0x460a0202, 0x470a0202, 0x480a0202, 0x490a0202, 0x4a0a0202, + 0x4b0a0202, 0x4c0a0202, 0x4d0a0202, 0x4e0a0202, 0x4f0a0202, 0x500a0202, 0x510a0202, 0x520a0202, + 0x530a0202, 0x540a0202, 0x550a0202, 0x560a0202, 0x570a0202, 0x580a0202, 0x590a0202, 0x5a0a0202, + 0x5b0a0202, 0x5c0a0202, 0x5d0a0202, 0x5e0a0202, 0x5f0a0202, 0x600a0202, 0x610a0202, 0x620a0202, + 0x630a0202, 0x640a0202, 0x650a0202, 0x660a0202, 0x670a0202, 0x680a0202, 0x690a0202, 0x6a0a0202, + 0x6b0a0202, 0x6c0a0202, 0x6d0a0202, 0x6e0a0202, 0x6f0a0202, 0x700a0202, 0x710a0202, 0x720a0202, + 0x730a0202, 0x740a0202, 0x750a0202, 0x760a0202, 0x770a0202, 0x780a0202, 0x790a0202, 0x7a0a0202, + 0x7b0a0202, 0x7c0a0202, 0x7d0a0202, 0x7e0a0202, 0x7f0a0202, 0x800a0202, 0x810a0202, 0x820a0202, + 0x830a0202, 0x840a0202, 0x850a0202, 0x860a0202, 0x870a0202, 0x880a0202, 0x890a0202, 0x8a0a0202, + 0x8b0a0202, 0x8c0a0202, 0x8d0a0202, 0x8e0a0202, 0x8f0a0202, 0x900a0202, 0x910a0202, 0x920a0202, + 0x090b0202, 0x0a0b0202, 0x0b0b0202, 0x0b0b0402, 0x0b0b0602, 0x0b0b0802, 0x0b0b0a02, 0x0b0b0c02, + 0x0b0b0e02, 0x0b0b1002, 0x0b0b1202, 0x0b0b1402, 0x0b0b1602, 0x0b0b1802, 0x710c0202, 0x720c0202, + 0x1a0df202, 0x1c0df202, 0x1e0df202, 0x200df202, 0x220df202, 0x240df202, 0x170b0202, 0x180b0202, + 0x190b0202, 0x1a0b0202, 0x1b0b0202, 0x1c0b0202, 0x1d0b0202, 0x1e0b0202, 0x1f0b0202, 0x200b0202, + 0x210b0202, 0x220b0202, 0x730c0202, 0x740c0202, 0x750c0202, 0x760c0202, 0x770c0202, 0x780c0202, + 0x790c0202, 0x7a0c0202, 0x7b0c0202, 0x7c0c0202, 0x7d0c0202, 0xfe0c0202, 0xfe0c0302, 0xfe0c0402, + 0x230b0202, 0x240b0202, 0x7e0c0202, 0x7f0c0202, 0x800c0202, 0x810c0202, 0x820c0202, 0x830c0202, + 0x840c0202, 0x850c0202, 0x860c0202, 0x870c0202, 0x880c0202, 0x890c0202, 0x8a0c0202, 0x8b0c0202, + 0x8c0c0202, 0x8d0c0202, 0x8d0c1402, 0x8d0c1502, 0x8d0c1602, 0x8d0c1702, 0x8d0c1802, 0x8d0c1902, + 0x8d0c1a02, 0x8d0c1b02, 0x8d0c1c02, 0x8d0c1d02, 0x8d0c1e02, 0x00000000, 0x00000000, 0x00000000, + 0x8d0c1f02, 0x8d0c2002, 0x8d0c2102, 0x8d0c2202, 0x8d0c2302, 0x8d0c2402, 0x8d0c2502, 0x8d0c2602, + 0x8d0c2702, 0x8d0c2802, 0x8d0c2902, 0x8d0c2a02, 0x8d0c2b02, 0x8d0c2c02, 0x8d0c2d02, 0x8d0c2e02, + 0x8d0c2f02, 0x8d0c3002, 0x8d0c3102, 0x8d0c3202, 0x8d0c3302, 0x8d0c3402, 0x8d0c3502, 0x8d0c3602, + 0x8d0c3702, 0x8d0c3802, 0x8d0c3902, 0x8d0c3a02, 0x8d0c3b02, 0x8d0c3c02, 0x8d0c3d02, 0x8d0c3e02, + 0x8d0c3f02, 0x8d0c4002, 0x8d0c4102, 0x8d0c4202, 0x8d0c4302, 0x8d0c4402, 0x8d0c4502, 0x8d0c4602, + 0x8d0c4702, 0x8d0c4802, 0x8d0c4902, 0x8d0c4a02, 0x8d0c4b02, 0x8d0c4c02, 0x8d0c4d02, 0x8d0c4e02, + 0x8d0c4f02, 0x8d0c5002, 0x8d0c5102, 0x8d0c5202, 0x8d0c5302, 0x8d0c5402, 0x8d0c5502, 0x8d0c5602, + 0x8d0c5702, 0x8d0c5802, 0x8d0c5902, 0x8d0c5a02, 0x8d0c5b02, 0x8d0c5c02, 0x8d0c5d02, 0x8d0c5e02, + 0x00000000, 0x930a0202, 0x940a0202, 0x950a0202, 0x960a0202, 0xfb0a0202, 0x970a0202, 0x980a0202, + 0x990a0202, 0x9a0a0202, 0xfc0a0202, 0xfd0a0202, 0x9b0a0202, 0x9c0a0202, 0x9d0a0202, 0x9e0a0202, + 0x9f0a0202, 0xa00a0202, 0xa10a0202, 0xa20a0202, 0xa30a0202, 0xa40a0202, 0xa50a0202, 0xa60a0202, + 0xa70a0202, 0xa80a0202, 0xa90a0202, 0xaa0a0202, 0xab0a0202, 0xac0a0202, 0xad0a0202, 0xae0a0202, + 0xaf0a0202, 0xb00a0202, 0xb10a0202, 0xb20a0202, 0xb30a0202, 0xb40a0202, 0xb50a0202, 0xb60a0202, + 0xfe0a0202, 0xb70a0202, 0xbe0a0202, 0xb90a0202, 0xba0a0202, 0xbb0a0202, 0xbc0a0202, 0xbd0a0202, + 0xb80a0202, 0xbf0a0202, 0xc00a0202, 0xc10a0202, 0xc20a0202, 0xc30a0202, 0xc40a0202, 0xc50a0202, + 0xc60a0202, 0xc70a0202, 0xc80a0202, 0xc90a0202, 0xca0a0202, 0xcb0a0202, 0xcc0a0202, 0xcd0a0202, + 0xce0a0202, 0xcf0a0202, 0xd00a0202, 0xd10a0202, 0xd20a0202, 0xd30a0202, 0xd40a0202, 0xd50a0202, + 0xd60a0202, 0xd70a0202, 0xd80a0202, 0xd90a0202, 0xff0a0202, 0xda0a0202, 0xda0a0302, 0xdb0a0202, + 0xdc0a0202, 0xdd0a0202, 0xde0a0202, 0xde0a0302, 0xde0a0402, 0xde0a0502, 0xdf0a0202, 0xdf0a0302, + 0xe00a0202, 0xe10a0202, 0xe20a0202, 0xe30a0202, 0xe40a0202, 0xe50a0202, 0xe60a0202, 0xe60a0302, + 0xe60a0402, 0xe70a0202, 0xe80a0202, 0xe90a0202, 0xea0a0202, 0xeb0a0202, 0xec0a0202, 0xed0a0202, + 0x0b07c802, 0x0c07c802, 0x0b07d202, 0x0c07d202, 0x56070a02, 0x57070a02, 0x4c0b0e02, 0x4c0b1202, + 0x56071402, 0x57071402, 0x2607dc02, 0x2807dc02, 0x26076402, 0x28076402, 0x1a0d0214, 0x1c0d0214, + 0x1e0d0214, 0x200d0214, 0x220d0214, 0x240d0214, 0x260d0214, 0x280d0214, 0x2a0d0214, 0x2c0d0214, + 0x1a0d020a, 0x1c0d020a, 0x1e0d020a, 0x200d020a, 0x220d020a, 0x240d020a, 0x260d020a, 0x280d020a, + 0x2a0d020a, 0x2c0d020a, 0x1a0d0216, 0x1c0d0216, 0x1e0d0216, 0x200d0216, 0x220d0216, 0x240d0216, + 0x260d0216, 0x280d0216, 0x2a0d0216, 0x2c0d0216, 0xdb091702, 0x00000000, 0x00000000, 0x00000000, + 0xdc090502, 0xdb091802, 0xda090502, 0xdb091902, 0xdb091a02, 0xdb091b02, 0xdb091c02, 0xdb091d02, + 0xdb091e02, 0xdb091f02, 0xdb092102, 0xdb092202, 0xdb092302, 0xdb092402, 0xdb092502, 0xdb092602, + 0xdb092702, 0xdb092802, 0xdb092902, 0xdb092b02, 0xdb092e02, 0xdb093002, 0xdb093102, 0xdb093202, + 0x00000000, 0xdb093302, 0xdb093402, 0xdb093502, 0xdc090602, 0xdb093602, 0xda090602, 0xdc090702, + 0xdb093702, 0xda090702, 0xdb093902, 0xdb093a02, 0xdb093b02, 0xdb093c02, 0xdb093d02, 0x00000000, + 0x8e0c0202, 0x8f0c0202, 0x900c0202, 0x910c0202, 0x920c0202, 0x930c0202, 0x940c0202, 0xfa0c1d02, + 0xfa0c1e02, 0xfa0c1f02, 0xfa0c2002, 0x00000000, 0xff0c0202, 0x00000000, 0xff0c0302, 0xff0c0402, + 0x5f0b0202, 0x600b0202, 0x610b0202, 0x620b0202, 0x630b0202, 0x150b0202, 0x150b0402, 0x150b0602, + 0x160b0202, 0x160b0402, 0x640b0202, 0x160b0602, 0x650b0202, 0x160b0802, 0x160b0a02, 0x660b0202, + 0x670b0202, 0x2d0b0302, 0x2d0b0502, 0x2d0b0702, 0x2d0b0902, 0x2d0b0b02, 0x17077a02, 0x19077a02, + 0x56071e02, 0x57071e02, 0x56072802, 0x57072802, 0x56072902, 0x57072902, 0x56072a02, 0x57072a02, + 0x40090202, 0x40090202, 0x54090202, 0x55090202, 0x56090202, 0x57090202, 0x58090202, 0x59090202, + 0x3e090202, 0x3e090202, 0x3e090202, 0x5a090202, 0x5b090202, 0x3e090202, 0x78090202, 0x5c090202, + 0xfaa60202, 0xfba60202, 0xfca60202, 0xfda60202, 0xfea60202, 0xffa60202, 0x02a70202, 0x03a70202, + 0x04a70202, 0x05a70202, 0x06a70202, 0x07a70202, 0x08a70202, 0x09a70202, 0x0aa70202, 0x0ba70202, + 0x0ca70202, 0x0da70202, 0x0ea70202, 0x0fa70202, 0x10a70202, 0x11a70202, 0x12a70202, 0x13a70202, + 0x14a70202, 0x15a70202, 0x16a70202, 0x17a70202, 0x18a70202, 0x19a70202, 0x1aa70202, 0x1ba70202, + 0x1ca70202, 0x1da70202, 0x1ea70202, 0x1fa70202, 0x20a70202, 0x21a70202, 0x22a70202, 0x23a70202, + 0x24a70202, 0x25a70202, 0x26a70202, 0x27a70202, 0x28a70202, 0x29a70202, 0x2aa70202, 0x2ba70202, + 0x2ca70202, 0x2da70202, 0x2ea70202, 0x2fa70202, 0x30a70202, 0x31a70202, 0x32a70202, 0x33a70202, + 0x34a70202, 0x35a70202, 0x36a70202, 0x37a70202, 0x38a70202, 0x39a70202, 0x3aa70202, 0x3ba70202, + 0x3ca70202, 0x3da70202, 0x3ea70202, 0x3fa70202, 0x40a70202, 0x41a70202, 0x42a70202, 0x43a70202, + 0x44a70202, 0x45a70202, 0x46a70202, 0x47a70202, 0x48a70202, 0x49a70202, 0x4aa70202, 0x4ba70202, + 0x4ca70202, 0x4da70202, 0x4ea70202, 0x4fa70202, 0x50a70202, 0x51a70202, 0x52a70202, 0x53a70202, + 0x54a70202, 0x55a70202, 0x56a70202, 0x57a70202, 0x58a70202, 0x59a70202, 0x5aa70202, 0x5ba70202, + 0x5ca70202, 0x5da70202, 0x5ea70202, 0x5fa70202, 0x60a70202, 0x61a70202, 0x62a70202, 0x63a70202, + 0x64a70202, 0x65a70202, 0x66a70202, 0x67a70202, 0x68a70202, 0x69a70202, 0x6aa70202, 0x6ba70202, + 0x6ca70202, 0x6da70202, 0x6ea70202, 0x6fa70202, 0x70a70202, 0x71a70202, 0x72a70202, 0x73a70202, + 0x74a70202, 0x75a70202, 0x76a70202, 0x77a70202, 0x78a70202, 0x79a70202, 0x7aa70202, 0x7ba70202, + 0x7ca70202, 0x7da70202, 0x7ea70202, 0x7fa70202, 0x80a70202, 0x81a70202, 0x82a70202, 0x83a70202, + 0x84a70202, 0x85a70202, 0x86a70202, 0x87a70202, 0x88a70202, 0x89a70202, 0x8aa70202, 0x8ba70202, + 0x8ca70202, 0x8da70202, 0x8ea70202, 0x8fa70202, 0x90a70202, 0x91a70202, 0x92a70202, 0x93a70202, + 0x94a70202, 0x95a70202, 0x96a70202, 0x97a70202, 0x98a70202, 0x99a70202, 0x9aa70202, 0x9ba70202, + 0x9ca70202, 0x9da70202, 0x9ea70202, 0x9fa70202, 0xa0a70202, 0xa1a70202, 0xa2a70202, 0xa3a70202, + 0xa4a70202, 0xa5a70202, 0xa6a70202, 0xa7a70202, 0xa8a70202, 0xa9a70202, 0xaaa70202, 0xaba70202, + 0xaca70202, 0xada70202, 0xaea70202, 0xafa70202, 0xb0a70202, 0xb1a70202, 0xb2a70202, 0xb3a70202, + 0xb4a70202, 0xb5a70202, 0xb6a70202, 0xb7a70202, 0xb8a70202, 0xb9a70202, 0xbaa70202, 0xbba70202, + 0xbca70202, 0xbda70202, 0xbea70202, 0xbfa70202, 0xc0a70202, 0xc1a70202, 0xc2a70202, 0xc3a70202, + 0xc4a70202, 0xc5a70202, 0xc6a70202, 0xc7a70202, 0xc8a70202, 0xc9a70202, 0xcaa70202, 0xcba70202, + 0xcca70202, 0xcda70202, 0xcea70202, 0xcfa70202, 0xd0a70202, 0xd1a70202, 0xd2a70202, 0xd3a70202, + 0xd4a70202, 0xd5a70202, 0xd6a70202, 0xd7a70202, 0xd8a70202, 0xd9a70202, 0xdaa70202, 0xdba70202, + 0xdca70202, 0xdda70202, 0xdea70202, 0xdfa70202, 0xe0a70202, 0xe1a70202, 0xe2a70202, 0xe3a70202, + 0xe4a70202, 0xe5a70202, 0xe6a70202, 0xe7a70202, 0xe8a70202, 0xe9a70202, 0xeaa70202, 0xeca70202, + 0xeda70202, 0xeea70202, 0xefa70202, 0xf0a70202, 0xf1a70202, 0xf2a70202, 0xf3a70202, 0xf4a70202, + 0xf5a70202, 0xf6a70202, 0xf7a70202, 0xf8a70202, 0xf9a70202, 0xfaa70202, 0xfba70202, 0xfca70202, + 0x41093202, 0x3e090202, 0x77090202, 0x3e090202, 0x3e090202, 0x41092802, 0x3f090202, 0x3f090202, + 0x45090202, 0x51090202, 0x3f090202, 0x3f090202, 0x3e090202, 0x3e090202, 0x3e090202, 0x3f090202, + 0x3e090202, 0x5d090202, 0x4f090202, 0x4e090202, 0x4d090202, 0x3e090202, 0x41091e02, 0x41091402, + 0x41090202, 0x7a090202, 0x39090202, 0x79090202, 0x39090202, 0x3a090202, 0x3b090202, 0x3a090202, + 0x3b090202, 0x3c091402, 0x3c091e02, 0x3d090b02, 0x3d091502, 0x3d091f02, 0x3d092902, 0x3c092802, + 0x3c090a02, 0x3c093c02, 0x3c094602, 0x4c090202, 0x5f090202, 0x3c095002, 0x3c095a02, 0x3c096402, + 0x3c096e02, 0x3c097802, 0x3c093202, 0x53090202, 0x42092802, 0x42091e02, 0x42091402, 0x42090a02, + 0x60090202, 0x61090202, 0x62090202, 0x63090202, 0x64090202, 0x6d090202, 0x6c090202, 0x6a090202, + 0x50090202, 0x52090202, 0x46090202, 0x68090202, 0x47090202, 0x48090202, 0x49090202, 0x4a090202, + 0x4b090202, 0x41090a02, 0x43090402, 0x43092402, 0x43092202, 0x43092002, 0x43091e02, 0x43091c02, + 0x43091a02, 0x43091802, 0x43090202, 0x43091402, 0x43092602, 0x43091002, 0x43090e02, 0x43090c02, + 0x43090a02, 0x43090802, 0x43090602, 0x43093002, 0x43091202, 0x43091602, 0x43094402, 0x43093802, + 0x43093402, 0x43093202, 0x44091302, 0x44091102, 0x44090f02, 0x44090302, 0x44090b02, 0x44091502, + 0x44090902, 0x44090702, 0x43092e02, 0x43092c02, 0x43092a02, 0x43092802, 0x44090502, 0x44090d02, + 0x3e090202, 0x6e090202, 0x76090202, 0x70090202, 0x6b090202, 0x72090202, 0x73090202, 0x74090202, + 0x75090202, 0x71090202, 0x5e090202, 0x69090202, 0x6f090202, 0x67090202, 0x66090202, 0x65090202, + 0x680b0202, 0x320b0302, 0x320b0502, 0x26071402, 0x28071402, 0x0b074302, 0x0c074302, 0x2607f002, + 0x2807f002, 0x2607f002, 0x2807f002, 0x17071402, 0x19071402, 0x17072802, 0x19071e02, 0x17073c02, + 0x17071e02, 0x56073202, 0x57073202, 0x56077002, 0x57077002, 0x56077202, 0x57077202, 0x56077402, + 0x57077402, 0x690b0202, 0x6a0b0202, 0x330b0302, 0x330b0502, 0x330b0702, 0x330b0902, 0x330b0b02, + 0x330b0d02, 0x330b0f02, 0x330b1102, 0x330b1302, 0x330b1502, 0x330b1702, 0x330b1902, 0x330b1b02, + 0x87090202, 0x88090202, 0x89090202, 0x8a090202, 0x8b090202, 0x8c090202, 0x8d090202, 0x8e090202, + 0x26086502, 0x26081502, 0x26081f02, 0x8f090202, 0x90090202, 0x0408ee02, 0x2707ee02, 0x3f08ee02, + 0x3408ee02, 0xe808ee02, 0x670bee02, 0x0608ee02, 0x1d08ee02, 0x91090202, 0x0a08ee02, 0x0b08ee02, + 0x0e08ee02, 0x1408ee02, 0xc909ee02, 0xc909ef02, 0x340b1502, 0x340b1702, 0x340b1902, 0x340b1b02, + 0x340b1d02, 0x340b1f02, 0x350b1402, 0x350b1602, 0x350b1802, 0x350b1a02, 0x350b1c02, 0x350b1e02, + 0x350b2002, 0x360b0b02, 0x360b0d02, 0x360b0f02, 0x370b1502, 0x370b1702, 0x380b1502, 0x380b1702, + 0x390b1502, 0x390b1702, 0x3a0b1502, 0x3a0b1702, 0xff0d0f02, 0xff0d0b02, 0xff0d1102, 0x6b0b0202, + 0x6c0b0202, 0x6d0b0202, 0x6e0b0202, 0x3b0b0b02, 0x3b0b0d02, 0x3b0b0f02, 0x6f0b0202, 0x700b0202, + 0x3c0b0b02, 0x3c0b0d02, 0x92090202, 0x710b0202, 0x93090202, 0x94090202, 0x3d0b1502, 0x3d0b1702, + 0x3d0b1902, 0x3d0b1b02, 0x3d0b1d02, 0x3d0b1f02, 0x720b0202, 0x34080202, 0x08080c02, 0x3408c902, + 0x08081502, 0x34081502, 0x03086402, 0x0308c802, 0x56073c02, 0x57073c02, 0x03080302, 0x04080302, + 0xd1081502, 0xd1081f02, 0xd1082902, 0xca080a02, 0xca081402, 0xc9081402, 0xca08ef02, 0x41083c02, + 0x42083202, 0xd1083302, 0x89086502, 0x8c080202, 0x8c08fa02, 0x8d080202, 0xd7081502, 0xd7081f02, + 0x90080202, 0x91080202, 0xd3081502, 0xd3081f02, 0xd3082902, 0xd7082902, 0x96080202, 0xd7083302, + 0xd7083d02, 0x43082902, 0x44085f02, 0xd7084702, 0xd7085102, 0x97080202, 0x9e080202, 0x25081502, + 0x25081f02, 0x25082902, 0x03080402, 0x03080602, 0x03080802, 0x03080a02, 0x03080c02, 0x03080e02, + 0x03081002, 0x04080402, 0x04080602, 0x04080802, 0x04080a02, 0x03081202, 0x03081402, 0x9f080202, + 0x1c082802, 0x1c082302, 0xb5080202, 0xb6080202, 0x1c081e02, 0x1c081902, 0x1c081402, 0x1c080f02, + 0x1d08ee02, 0x03081602, 0x04080c02, 0x1c080a02, 0x05080202, 0x06080202, 0x07080a02, 0x08081402, + 0x43080502, 0x44085102, 0x44081902, 0x43080a02, 0x41083702, 0x42082d02, 0x44084702, 0x44085b02, + 0x44085102, 0x44084b02, 0x44085502, 0x43082902, 0x44083102, 0x43081502, 0x4308ef02, 0x44083c02, + 0x44083202, 0x41083202, 0x42082802, 0x41082d02, 0x42081e02, 0x41082802, 0x42081902, 0x09081502, + 0x0a081502, 0x42082302, 0x41081e02, 0x42081402, 0x41081902, 0x42080f02, 0x41081402, 0x41080f02, + 0x41080a02, 0x0b081502, 0x42080a02, 0x42080502, 0x0c081502, 0x0d081502, 0x0e081502, 0x0f081502, + 0x10081502, 0x11081502, 0x12081502, 0x13081502, 0x14081502, 0x15081502, 0x16081502, 0x17081502, + 0x18081502, 0x19081502, 0x1a081502, 0x1b081502, 0x1c081502, 0x12086402, 0x1208c802, 0x1d081502, + 0x1e081502, 0x1f081502, 0x20081502, 0x3e081502, 0x40088302, 0x3e080b02, 0x40080b02, 0x3e081502, + 0x40081502, 0x3e081f02, 0x40081f02, 0x3e082902, 0x40082902, 0x3e083302, 0x40083302, 0x3e083d02, + 0x40083d02, 0x3e084702, 0x40084702, 0x3e085102, 0x40085102, 0x3e085b02, 0x40085b02, 0x3e086502, + 0x40086502, 0x3e086f02, 0x40086f02, 0x3e087902, 0x40087902, 0xd8085b02, 0xd8086502, 0xd8086f02, + 0xd8087902, 0x46081502, 0x46081f02, 0x46082902, 0x46083302, 0x47083d02, 0x47084702, 0x47085102, + 0x47085b02, 0x49081502, 0x49081f02, 0x49082902, 0x40088d02, 0x40089702, 0x3e081f02, 0x4008a102, + 0x3e082902, 0x4008ab02, 0x63081502, 0x63081f02, 0x63082902, 0x63083302, 0xb7080202, 0x2a081502, + 0x2d081502, 0x2a081f02, 0x2d081f02, 0x2a082902, 0x2d082902, 0x2a083302, 0x2d083302, 0x2a083d02, + 0x2d083d02, 0x2a084702, 0x2d084702, 0x0f086402, 0x0f08c802, 0x98080e02, 0x99080c02, 0x98081002, + 0x99080e02, 0x98081202, 0x99081002, 0x98081402, 0x99081202, 0x98081f02, 0x99082602, 0x98081602, + 0x99081402, 0x98080c02, 0x99080a02, 0x98081802, 0x99081802, 0x4a083302, 0x4a083d02, 0x98081a02, + 0x99081a02, 0x98081c02, 0x99081c02, 0x99081e02, 0x99082102, 0x98081e02, 0x99082202, 0x99082402, + 0x99081602, 0x29080c02, 0xb8080202, 0x43083d02, 0xe7082002, 0xe7080202, 0x7a081502, 0x7a081f02, + 0x7a082902, 0xe8080202, 0x7c081502, 0x85081502, 0x7c081f02, 0x85081f02, 0xe9080202, 0x7a083302, + 0x7a083d02, 0x7a084702, 0x85082902, 0x85083302, 0x85083d02, 0xea080202, 0xf1080202, 0x61081502, + 0x61081f02, 0xf2080202, 0xf3080202, 0xf4080202, 0x5b081502, 0x5b081f02, 0x5b082902, 0x5b083302, + 0x5b083d02, 0x5e081502, 0x5e081f02, 0x20080202, 0x21080202, 0x22080202, 0xf9081502, 0xf9081f02, + 0x7b090202, 0x7c090202, 0x7d090202, 0x7e090202, 0x7f090202, 0x80090202, 0x81090202, 0x82090202, + 0x7b090302, 0x7c090302, 0x7d090302, 0x7e090302, 0x83090202, 0x84090202, 0x950c0202, 0x960c0202, + 0x970c0202, 0x980c0202, 0x990c0202, 0x9a0c0202, 0x020a0202, 0x020a0c02, 0x030a0202, 0x030a0c02, + 0x030a1602, 0x030a2002, 0xd3070c02, 0xd3070d02, 0xd3070e02, 0xd3070f02, 0xd3071002, 0xda070202, + 0x8f0c3402, 0x8f0c5202, 0x8f0c5302, 0x8f0c5402, 0x8f0c5502, 0x8f0c5602, 0x8f0c5702, 0x8f0c5802, + 0x8f0c5902, 0x8f0c5a02, 0x8f0c5b02, 0x8f0c5c02, 0x8f0c5d02, 0x8f0c5e02, 0x8f0c5f02, 0x8f0c6002, + 0x8f0c6102, 0x8f0c6202, 0x8f0c6302, 0x8f0c6402, 0x8f0c6502, 0x8f0c6602, 0x8f0c6702, 0x8f0c6802, + 0x8f0c6902, 0x8f0c6a02, 0x8f0c6b02, 0x8f0c6c02, 0x8f0c6d02, 0x8f0c6e02, 0x8f0c6f02, 0x8f0c7002, + 0x8f0c7102, 0x8f0c7202, 0x8f0c7302, 0x8f0c7402, 0x8f0c7502, 0x8f0c7602, 0x8f0c7702, 0x8f0c7802, + 0x8f0c7902, 0x8f0c7a02, 0x8f0c7b02, 0x8f0c7c02, 0x8f0c7d02, 0x00000000, 0x00000000, 0x00000000, + 0x8f0c7e02, 0x8f0c7f02, 0x8f0c8002, 0x8f0c8102, 0x8f0c8202, 0x8f0c8302, 0x8f0c8402, 0x8f0c8502, + 0x8f0c8602, 0x8f0c8702, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x02130212, 0x04130212, 0x06130212, 0x08130212, 0x0a130212, 0x0c130212, 0x0e130212, 0x10130212, + 0x12130212, 0x14130212, 0x16130212, 0x18130212, 0x1a130212, 0x1c130212, 0x1e130212, 0x20130212, + 0x22130212, 0x24130212, 0x26130212, 0x28130212, 0x2a130212, 0x2c130212, 0x2e130212, 0x30130212, + 0x32130212, 0x34130212, 0x36130212, 0x38130212, 0x3a130212, 0x3c130212, 0x3e130212, 0x40130212, + 0x42130212, 0x44130212, 0x46130212, 0x48130212, 0x4a130212, 0x4c130212, 0x4e130212, 0x50130212, + 0x52130212, 0x54130212, 0x56130212, 0x58130212, 0x5a130212, 0x5c130212, 0x5e130212, 0x00000000, + 0x02130202, 0x04130202, 0x06130202, 0x08130202, 0x0a130202, 0x0c130202, 0x0e130202, 0x10130202, + 0x12130202, 0x14130202, 0x16130202, 0x18130202, 0x1a130202, 0x1c130202, 0x1e130202, 0x20130202, + 0x22130202, 0x24130202, 0x26130202, 0x28130202, 0x2a130202, 0x2c130202, 0x2e130202, 0x30130202, + 0x32130202, 0x34130202, 0x36130202, 0x38130202, 0x3a130202, 0x3c130202, 0x3e130202, 0x40130202, + 0x42130202, 0x44130202, 0x46130202, 0x48130202, 0x4a130202, 0x4c130202, 0x4e130202, 0x50130202, + 0x52130202, 0x54130202, 0x56130202, 0x58130202, 0x5a130202, 0x5c130202, 0x5e130202, 0x00000000, + 0x480e1b12, 0x480e1b02, 0x480e1912, 0x7e0e1b12, 0x8a0e4312, 0x020e1c02, 0x990e6502, 0x2c0e6512, + 0x2c0e6502, 0x360e6512, 0x360e6502, 0xa90e6512, 0xa90e6502, 0x020e7c12, 0x510e4312, 0x020e7b12, + 0x020e7d03, 0xa20e7e02, 0xa40e5912, 0xa40e5902, 0xa20e6702, 0x300e0212, 0x300e0202, 0x7e0e7902, + 0x210e6902, 0x8a0e8502, 0x7c0e6a02, 0x210e7d16, 0x350e0204, 0xa20e021a, 0x910e5c12, 0xa90e5c12, + 0x02140212, 0x02140202, 0x04140212, 0x04140202, 0x06140212, 0x06140202, 0x08140212, 0x08140202, + 0x0a140212, 0x0a140202, 0x0c140212, 0x0c140202, 0x0e140212, 0x0e140202, 0x10140212, 0x10140202, + 0x12140212, 0x12140202, 0x14140212, 0x14140202, 0x16140212, 0x16140202, 0x18140212, 0x18140202, + 0x1a140212, 0x1a140202, 0x1c140212, 0x1c140202, 0x1e140212, 0x1e140202, 0x20140212, 0x20140202, + 0x22140212, 0x22140202, 0x24140212, 0x24140202, 0x26140212, 0x26140202, 0x28140212, 0x28140202, + 0x2a140212, 0x2a140202, 0x2c140212, 0x2c140202, 0x2e140212, 0x2e140202, 0x30140212, 0x30140202, + 0x32140212, 0x32140202, 0x34140212, 0x34140202, 0x36140212, 0x36140202, 0x38140212, 0x38140202, + 0x3a140212, 0x3a140202, 0x3c140212, 0x3c140202, 0x3e140212, 0x3e140202, 0x40140212, 0x40140202, + 0x42140212, 0x42140202, 0x44140212, 0x44140202, 0x46140212, 0x46140202, 0x48140212, 0x48140202, + 0x4a140212, 0x4a140202, 0x4c140212, 0x4c140202, 0x4e140212, 0x4e140202, 0x50140212, 0x50140202, + 0x52140212, 0x52140202, 0x54140212, 0x54140202, 0x56140212, 0x56140202, 0x58140212, 0x58140202, + 0x5a140212, 0x5a140202, 0x5c140212, 0x5c140202, 0x5e140212, 0x5e140202, 0x60140212, 0x60140202, + 0x62140212, 0x62140202, 0x64140212, 0x64140202, 0x9b0c0202, 0x9c0c0202, 0x9d0c0202, 0x9e0c0202, + 0x9f0c0202, 0xa00c0202, 0xa10c0202, 0x490f0212, 0x490f0202, 0x510f0212, 0x510f0202, 0x00018f00, + 0x00019600, 0x00019700, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x33072902, 0x3c072902, 0x3c073302, 0x46072902, 0x110d0302, 0x33143302, 0x47143302, + 0x65120202, 0x66120202, 0x67120202, 0x68120202, 0x69120202, 0x6a120202, 0x6b120202, 0x6d120202, + 0x6e120202, 0x6f120202, 0x70120202, 0x71120202, 0x72120202, 0x74120202, 0x75120202, 0x76120202, + 0x77120202, 0x78120202, 0x79120202, 0x7a120202, 0x7c120202, 0x7d120202, 0x7e120202, 0x7f120202, + 0x80120202, 0x81120202, 0x82120202, 0x83120202, 0x84120202, 0x85120202, 0x86120202, 0x88120202, + 0x89120202, 0x6c120202, 0x73120202, 0x7b120202, 0x87120202, 0x8a120202, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x034d0202, 0x054d0202, 0x074d0202, 0x094d0202, 0x0b4d0202, 0x0d4d0202, 0x0f4d0202, 0x114d0202, + 0x134d0202, 0x154d0202, 0x174d0202, 0x194d0202, 0x1b4d0202, 0x1d4d0202, 0x1f4d0202, 0x214d0202, + 0x234d0202, 0x254d0202, 0x274d0202, 0x294d0202, 0x2b4d0202, 0x2d4d0202, 0x2f4d0202, 0x314d0202, + 0x334d0202, 0x354d0202, 0x374d0202, 0x394d0202, 0x3b4d0202, 0x3d4d0202, 0x3f4d0202, 0x414d0202, + 0x434d0202, 0x454d0202, 0x474d0202, 0x494d0202, 0x4b4d0202, 0x4d4d0202, 0x4f4d0202, 0x514d0202, + 0x534d0202, 0x554d0202, 0x574d0202, 0x594d0202, 0x5b4d0202, 0x5d4d0202, 0x5f4d0202, 0x614d0202, + 0x634d0202, 0x654d0202, 0x674d0202, 0x694d0202, 0x6b4d0202, 0x6d4d0202, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x6f4d0202, + 0x02074b02, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00010b00, + 0x1b530202, 0x1c530202, 0x1d530202, 0x1e530202, 0x1f530202, 0x20530202, 0x21530202, 0x22530202, + 0x23530202, 0x24530202, 0x25530202, 0x26530202, 0x27530202, 0x28530202, 0x29530202, 0x2a530202, + 0x2b530202, 0x2c530202, 0x2d530202, 0x2e530202, 0x2f530202, 0x30530202, 0x31530202, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x32530202, 0x33530202, 0x34530202, 0x35530202, 0x36530202, 0x37530202, 0x38530202, 0x00000000, + 0x39530202, 0x3a530202, 0x3b530202, 0x3c530202, 0x3d530202, 0x3e530202, 0x3f530202, 0x00000000, + 0x40530202, 0x41530202, 0x42530202, 0x43530202, 0x44530202, 0x45530202, 0x46530202, 0x00000000, + 0x47530202, 0x48530202, 0x49530202, 0x4a530202, 0x4b530202, 0x4c530202, 0x4d530202, 0x00000000, + 0x4e530202, 0x4f530202, 0x50530202, 0x51530202, 0x52530202, 0x53530202, 0x54530202, 0x00000000, + 0x55530202, 0x56530202, 0x57530202, 0x58530202, 0x59530202, 0x5a530202, 0x5b530202, 0x00000000, + 0x5c530202, 0x5d530202, 0x5e530202, 0x5f530202, 0x60530202, 0x61530202, 0x62530202, 0x00000000, + 0x63530202, 0x64530202, 0x65530202, 0x66530202, 0x67530202, 0x68530202, 0x69530202, 0x00000000, + 0x06100302, 0x08100302, 0x0a100302, 0x0f100302, 0x1b100302, 0x1e100302, 0x2e100302, 0x32100302, + 0x38100302, 0x3a100302, 0x48100302, 0x4f100302, 0x51100302, 0x53100302, 0x57100302, 0x6f100302, + 0x75100302, 0x78100302, 0x84100302, 0x87100302, 0xc6100302, 0x53100402, 0x02100302, 0x14100302, + 0x2d100302, 0x6a100302, 0xae100302, 0xa2100302, 0xa4100302, 0xb4100302, 0xba100302, 0xbd100302, + 0xc8070202, 0xc9070202, 0xca070202, 0xcb070202, 0xcc070202, 0xcd070202, 0xce070202, 0xcf070202, + 0xd0070202, 0xd1070202, 0xd2070202, 0xd3070202, 0xd4070202, 0xd5070202, 0xd6070202, 0xd7070202, + 0xd8070202, 0xd9070202, 0xda070202, 0xdb070202, 0xdc070202, 0xdd070202, 0xde070202, 0xdf070202, + 0x3c07c902, 0xee070202, 0xf0070202, 0x50070302, 0xe0070202, 0xe1070202, 0x50070402, 0x50070502, + 0x3f071d02, 0x42071d02, 0x17078c02, 0x19078c02, 0x17078d02, 0x19078d02, 0x5607c802, 0x5707c802, + 0x27072802, 0x2a072802, 0x1a072002, 0x1a072102, 0x1a072a02, 0x1a074802, 0x3c070a02, 0xfe100202, + 0xef070202, 0xef070302, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x02a60202, 0x03a60202, 0x04a60202, 0x05a60202, 0x06a60202, 0x07a60202, 0x08a60202, 0x09a60202, + 0x0aa60202, 0x0ba60202, 0x0ca60202, 0x0da60202, 0x0ea60202, 0x0fa60202, 0x10a60202, 0x11a60202, + 0x12a60202, 0x13a60202, 0x14a60202, 0x15a60202, 0x16a60202, 0x17a60202, 0x18a60202, 0x19a60202, + 0x1aa60202, 0x1ba60202, 0x00000000, 0x1ca60202, 0x1da60202, 0x1ea60202, 0x1fa60202, 0x00000000, + 0x21a60202, 0x22a60202, 0x23a60202, 0x24a60202, 0x25a60202, 0x26a60202, 0x27a60202, 0x28a60202, + 0x29a60202, 0x2aa60202, 0x2ba60202, 0x2ca60202, 0x2da60202, 0x2ea60202, 0x2fa60202, 0x30a60202, + 0x31a60202, 0x32a60202, 0x33a60202, 0x34a60202, 0x35a60202, 0x36a60202, 0x37a60202, 0x38a60202, + 0x39a60202, 0x3aa60202, 0x3ba60202, 0x3ca60202, 0x3da60202, 0x3ea60202, 0x3fa60202, 0x40a60202, + 0x41a60202, 0x42a60202, 0x43a60202, 0x44a60202, 0x45a60202, 0x46a60202, 0x47a60202, 0x48a60202, + 0x49a60202, 0x4aa60202, 0x4ba60202, 0x4ca60202, 0x4da60202, 0x4ea60202, 0x4fa60202, 0x50a60202, + 0x51a60202, 0x52a60202, 0x53a60202, 0x54a60202, 0x55a60202, 0x56a60202, 0x57a60202, 0x58a60202, + 0x59a60202, 0x5aa60202, 0x5ba60202, 0x5ca60202, 0x5da60202, 0x5ea60202, 0x5fa60202, 0x60a60202, + 0x61a60202, 0x62a60202, 0x63a60202, 0x64a60202, 0x65a60202, 0x66a60202, 0x67a60202, 0x68a60202, + 0x69a60202, 0x6aa60202, 0x6ba60202, 0x6ca60202, 0x6da60202, 0x6ea60202, 0x6fa60202, 0x70a60202, + 0x71a60202, 0x72a60202, 0x73a60202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xa20c0202, 0xa30c0202, 0xa40c0202, 0xa50c0202, 0xa60c0202, 0xa70c0202, 0xa80c0202, 0xa90c0202, + 0xaa0c0202, 0xab0c0202, 0xac0c0202, 0xad0c0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x02070203, 0x31070203, 0x34070203, 0xd9070202, 0x2d0a0202, 0x00030527, 0xda070202, 0x030de702, + 0x93070202, 0x95070202, 0x97070202, 0x99070202, 0x9b070203, 0x9d070203, 0x9f070202, 0xa1070202, + 0xa3070202, 0xa5070202, 0x280a0202, 0x290a0202, 0xa8070202, 0xab070202, 0xad070202, 0xae070202, + 0xaf070202, 0xb0070202, 0xb1070202, 0xb2070202, 0x93060202, 0xb3070202, 0xb4070202, 0xb5070202, + 0x2a0a0202, 0x1a0de702, 0x1c0de702, 0x1e0de702, 0x200de702, 0x220de702, 0x240de702, 0x260de702, + 0x280de702, 0x2a0de702, 0x00010700, 0x00010800, 0x00010900, 0x00010b00, 0x00010700, 0x00010800, + 0x94060202, 0x00030227, 0x00030327, 0x00030227, 0x00030327, 0x00030227, 0x2b0a0202, 0xae0c0202, + 0x2c0de702, 0x360de702, 0x400de702, 0x00030527, 0x00010300, 0x00010300, 0x00010300, 0x2c0a0202, + 0x00000000, 0x02030225, 0x02030227, 0x03030225, 0x03030227, 0x04030225, 0x04030227, 0x05030225, + 0x05030227, 0x06030225, 0x06030227, 0x0a030227, 0x0a030327, 0x0b030227, 0x0b030327, 0x0c030227, + 0x0c030327, 0x0d030227, 0x0d030327, 0x0e030227, 0x0e030327, 0x12030227, 0x12030327, 0x13030227, + 0x13030327, 0x14030227, 0x14030327, 0x15030227, 0x15030327, 0x16030227, 0x16030327, 0x1a030227, + 0x1a030327, 0x1b030227, 0x1b030327, 0x1c030225, 0x1c030227, 0x1c030327, 0x1d030227, 0x1d030327, + 0x1e030227, 0x1e030327, 0x22030227, 0x23030227, 0x24030227, 0x25030227, 0x26030227, 0x2a030227, + 0x2a030327, 0x2a030427, 0x2b030227, 0x2b030327, 0x2b030427, 0x2c030227, 0x2c030327, 0x2c030427, + 0x2d030227, 0x2d030327, 0x2d030427, 0x2e030227, 0x2e030327, 0x2e030427, 0x32030227, 0x33030227, + 0x34030227, 0x35030227, 0x36030227, 0x3a030225, 0x3a030227, 0x3c030225, 0x3c030227, 0x3e030225, + 0x3e030227, 0x42030227, 0x43030227, 0x44030227, 0x45030227, 0x46030227, 0x4a030225, 0x4a030227, + 0x4b030227, 0x4d030227, 0x4e030227, 0x80030227, 0x04030327, 0x0a030225, 0x0d030225, 0x00000000, + 0x00000000, 0x00010300, 0x00010400, 0x00010300, 0x00010400, 0x00030227, 0x00030327, 0x00000000, + 0x00030000, 0x02030205, 0x02030207, 0x03030205, 0x03030207, 0x04030205, 0x04030207, 0x05030205, + 0x05030207, 0x06030205, 0x06030207, 0x0a030207, 0x0a030307, 0x0b030207, 0x0b030307, 0x0c030207, + 0x0c030307, 0x0d030207, 0x0d030307, 0x0e030207, 0x0e030307, 0x12030207, 0x12030307, 0x13030207, + 0x13030307, 0x14030207, 0x14030307, 0x15030207, 0x15030307, 0x16030207, 0x16030307, 0x1a030207, + 0x1a030307, 0x1b030207, 0x1b030307, 0x1c030205, 0x1c030207, 0x1c030307, 0x1d030207, 0x1d030307, + 0x1e030207, 0x1e030307, 0x22030207, 0x23030207, 0x24030207, 0x25030207, 0x26030207, 0x2a030207, + 0x2a030307, 0x2a030407, 0x2b030207, 0x2b030307, 0x2b030407, 0x2c030207, 0x2c030307, 0x2c030407, + 0x2d030207, 0x2d030307, 0x2d030407, 0x2e030207, 0x2e030307, 0x2e030407, 0x32030207, 0x33030207, + 0x34030207, 0x35030207, 0x36030207, 0x3a030205, 0x3a030207, 0x3c030205, 0x3c030207, 0x3e030205, + 0x3e030207, 0x42030207, 0x43030207, 0x44030207, 0x45030207, 0x46030207, 0x4a030205, 0x4a030207, + 0x4b030207, 0x4d030207, 0x4e030207, 0x80030207, 0x04030307, 0x0a030205, 0x0d030205, 0x4a030307, + 0x4b030307, 0x4d030307, 0x4e030307, 0x0e0a0203, 0x01030227, 0x00030207, 0x00030307, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x02a40202, 0x03a40202, 0x04a40202, + 0x05a40202, 0x07a40202, 0x08a40202, 0x09a40202, 0x0aa40202, 0x0ba40202, 0x0ca40202, 0x0fa40202, + 0x10a40202, 0x11a40202, 0x12a40202, 0x14a40202, 0x15a40202, 0x16a40202, 0x17a40202, 0x18a40202, + 0x19a40202, 0x1aa40202, 0x1ba40202, 0x1ca40202, 0x1ea40202, 0x1fa40202, 0x21a40202, 0x22a40202, + 0x23a40202, 0x24a40202, 0x25a40202, 0x26a40202, 0x27a40202, 0x29a40202, 0x2da40202, 0x2ea40202, + 0x2fa40202, 0x30a40202, 0x06a40202, 0x0da40202, 0x13a40202, 0x31a40202, 0x00000000, 0x00000000, + 0x00000000, 0x02c00207, 0x55c20207, 0xa7c40207, 0xa9c40207, 0x04c70207, 0x06c70207, 0x07c70207, + 0x61c90207, 0xb3cb0207, 0x06ce0207, 0x0cce0207, 0x0fce0207, 0x13ce0207, 0x17ce0207, 0x18ce0207, + 0x19ce0207, 0x1cce0207, 0x76d00207, 0xccd20207, 0x1fd50207, 0x2cd50207, 0x86d70207, 0xe4d90207, + 0x48dc0207, 0x9fde0207, 0xf4e00207, 0x4ce30207, 0x9de50207, 0xefe70207, 0x46ea0207, 0xa0ed0207, + 0xa3ed0207, 0xa4ed0207, 0xa7ed0207, 0xa8ed0207, 0xaced0207, 0xaded0207, 0xb0ed0207, 0xb1ed0207, + 0xb2ed0207, 0xb3ed0207, 0xb9ed0207, 0xbaed0207, 0xc0ed0207, 0xc3ed0207, 0xc5ed0207, 0xc8ed0207, + 0xc9ed0207, 0xd1ed0207, 0xd5ed0207, 0xd7ed0207, 0x9fed0207, 0xfcc60206, 0xfec60206, 0x02c70206, + 0x03c70206, 0x07ce0206, 0x09ce0206, 0x10ce0206, 0x15ce0206, 0x1ace0206, 0x6fd00206, 0x70d00206, + 0x72d00206, 0x75d00206, 0xc8d20206, 0xcad20206, 0x20d50206, 0x21d50206, 0x25d50206, 0x27d50206, + 0x2ad50206, 0x2bd50206, 0x7fd70206, 0x80d70206, 0x81d70206, 0x84d70206, 0xd9d90206, 0xe3d90206, + 0x3fdc0206, 0x45dc0206, 0x46dc0206, 0x47dc0206, 0x45ea0206, 0x9ded0206, 0x9eed0206, 0xbbed0206, + 0xbced0206, 0xbfed0206, 0xcded0206, 0xceed0206, 0xd0ed0206, 0xdeed0206, 0xe1ed0206, 0x00000000, + 0x00000000, 0x00000000, 0x3c050202, 0x3c050302, 0x3c050402, 0x3c050502, 0x3c050602, 0x3c050702, + 0x3c050802, 0x3c050902, 0x3c050a02, 0x3c050b02, 0x3c050c02, 0x3c050d02, 0x3c050e02, 0x3c050f02, + 0x02a42a02, 0x18a42a02, 0x10a42a02, 0x0ba42a02, 0x20a40202, 0x20a42a02, 0x1da40202, 0x1ca42a02, + 0x2fa45402, 0x1ba42a02, 0x2ea42a02, 0x2fa42a02, 0x2ca40202, 0x0ea40202, 0x21a42a02, 0x23a42a02, + 0x2aa40202, 0x2ba40202, 0x28a40202, 0x2ea45402, 0x03a42a02, 0x08a42a02, 0x0ca42a02, 0x0fa42a02, + 0x32a40202, 0x33a40202, 0x34a40202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x5aa80202, 0x5ba80202, 0x5ca80202, 0x5da80202, 0x5ea80202, 0x5fa80202, 0x60a80202, 0x61a80202, + 0x62a80202, 0x63a80202, 0x64a80202, 0x65a80202, 0x66a80202, 0x67a80202, 0x68a80202, 0x69a80202, + 0x6aa80202, 0x6ba80202, 0x6ca80202, 0x6da80202, 0x6ea80202, 0x6fa80202, 0x70a80202, 0x71a80202, + 0x72a80202, 0x73a80202, 0x74a80202, 0x75a80202, 0x76a80202, 0x77a80202, 0x78a80202, 0x79a80202, + 0x7aa80202, 0x7ba80202, 0x7ca80202, 0x7da80202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x0c030305, 0x13030205, 0x14030205, 0x1e030205, 0x24030205, 0x2a030205, 0x2b030205, 0x2c030205, + 0x2d030205, 0x2e030205, 0x34030205, 0x42030205, 0x43030205, 0x44030205, 0x45030205, 0x46030205, + 0x02c00302, 0xa9c40302, 0x07c70302, 0xb3cb0302, 0x1cce0302, 0x76d00302, 0x2cd50302, 0xe4d90302, + 0x48dc0302, 0xf4e00302, 0x4ce30302, 0x9de50302, 0xefe70302, 0x46ea0302, 0x03c00302, 0xaac40302, + 0x08c70402, 0xb4cb0302, 0x1dce0302, 0x77d00302, 0x2dd50302, 0xe5d90302, 0x49dc0302, 0xf5e00302, + 0x4de30302, 0x9ee50302, 0xf0e70302, 0x47ea0302, 0xbadd0402, 0xfbda031a, 0xfbda0312, 0x00000000, + 0x3c051002, 0x3c051102, 0x3c051202, 0x3c051302, 0x3c051402, 0x3c051502, 0x3c051602, 0x3c051702, + 0x3c051802, 0x3c051902, 0x3c051a02, 0x3c051b02, 0x3c051c02, 0x3c051d02, 0x3c051e02, 0x3c051f02, + 0x3c052002, 0x3c052102, 0x3c052202, 0x3c052302, 0x3c052402, 0x3c052502, 0x3c052602, 0x3c052702, + 0x3c052802, 0x3c052902, 0x3c052a02, 0x3c052b02, 0x3c052c02, 0x3c052d02, 0x3c052e02, 0x3c052f02, + 0x3c053002, 0x3c053102, 0x3c053202, 0x3c053302, 0xa805f002, 0xa805f102, 0x54052102, 0xa805f302, + 0x2c0d0216, 0x360d0214, 0x400d0214, 0x4a0d0214, 0x540d0214, 0x560d0214, 0x580d0214, 0x5a0d0214, + 0xfe070202, 0x370d0206, 0x380d0206, 0x390d0206, 0x3a0d0206, 0x3b0d0206, 0x3c0d0206, 0x3d0d0206, + 0x3e0d0206, 0x3f0d0206, 0x400d0206, 0x410d0206, 0x420d0206, 0x430d0206, 0x440d0206, 0x450d0206, + 0x02c00402, 0xa9c40402, 0x07c70402, 0xb3cb0402, 0x1cce0402, 0x76d00402, 0x2cd50402, 0xe4d90402, + 0x48dc0402, 0xf4e00402, 0x4ce30402, 0x9de50402, 0xefe70402, 0x46ea0402, 0x03c00402, 0xaac40402, + 0x09c70202, 0xb4cb0402, 0x1dce0402, 0x77d00402, 0x2dd50402, 0xe5d90402, 0x49dc0402, 0xf5e00402, + 0x4de30402, 0x9ee50402, 0xf0e70402, 0x47ea0402, 0x37e10412, 0xecdd0412, 0x55db0302, 0x2e0a0202, + 0x3c053402, 0x3c053502, 0x3c053602, 0x3c053702, 0x3c053802, 0x3c053902, 0x3c053a02, 0x3c053b02, + 0x3c053c02, 0x3c053d02, 0x3c053e02, 0x3c053f02, 0x3c054002, 0x3c054102, 0x3c054202, 0x3c054302, + 0x3c054402, 0x3c054502, 0x3c054602, 0x3c054702, 0x3c054802, 0x3c054902, 0x3c054a02, 0x3c054b02, + 0x3c054c02, 0x3c054d02, 0x3c054e02, 0x3c054f02, 0x3c055002, 0x3c055102, 0x3c055202, 0x3c055302, + 0x3c055402, 0x3c055502, 0x3c055602, 0x3c055702, 0x3c055802, 0x3c055902, 0x3c055a02, 0x3c055b02, + 0x3c055c02, 0x3c055d02, 0x3c055e02, 0x3c055f02, 0x3c056002, 0x3c056102, 0x3c056202, 0x3c056302, + 0x3c056402, 0x460d0206, 0x470d0206, 0x480d0206, 0x490d0206, 0x4a0d0206, 0x4b0d0206, 0x4c0d0206, + 0x4d0d0206, 0x4e0d0206, 0x4f0d0206, 0x500d0206, 0x510d0206, 0x520d0206, 0x530d0206, 0x540d0206, + 0x1a0df102, 0x1c0df102, 0x1e0df102, 0x200df102, 0x220df102, 0x240df102, 0x260df102, 0x280df102, + 0x2a0df102, 0x2c0df102, 0x2c0df102, 0x2d0df102, 0x00000000, 0x91a30202, 0x00000000, 0xfd070202, + 0x0203ee07, 0x0303ee07, 0x0403ee07, 0x0503ee07, 0x0603ee07, 0x0a03ee07, 0x0b03ee07, 0x0c03ee07, + 0x0d03ee07, 0x0e03ee07, 0x1203ee07, 0x1303ee07, 0x1403ee07, 0x1503ee07, 0x1603ee07, 0x1a03ee07, + 0x1b03ee07, 0x1c03ee07, 0x1d03ee07, 0x1e03ee07, 0x2203ee07, 0x2303ee07, 0x2403ee07, 0x2503ee07, + 0x2603ee07, 0x2a03ee07, 0x2b03ee07, 0x2c03ee07, 0x2d03ee07, 0x2e03ee07, 0x3203ee07, 0x3303ee07, + 0x3403ee07, 0x3503ee07, 0x3603ee07, 0x3a03ee07, 0x3c03ee07, 0x3e03ee07, 0x4203ee07, 0x4303ee07, + 0x4403ee07, 0x4503ee07, 0x4603ee07, 0x4a03ee07, 0x4b03ee07, 0x4d03ee07, 0x4e03ee07, 0x00000000, + 0xa8a30202, 0xa9a30202, 0xa7a30202, 0x9da30202, 0xc1a30202, 0xc2a30202, 0xeba30202, 0xb2a30202, + 0xb1a30202, 0xd8a30202, 0xd9a30202, 0xc3a30202, 0xc4a30202, 0xa1a30202, 0xb4a30202, 0xb3a30202, + 0xb5a30202, 0xb6a30202, 0xcda30202, 0xb7a30202, 0x98a30202, 0xc6a30202, 0xc7a30202, 0xc8a30202, + 0x9ba30202, 0xb8a30202, 0xcca30202, 0xcba30202, 0xc5a30202, 0xcaa30202, 0xc9a30202, 0xe8a30202, + 0xe9a30202, 0xeaa30202, 0x99a30202, 0xa3a30202, 0xafa30202, 0xb0a30202, 0xa2a30202, 0x9ca30202, + 0xd6a30202, 0xd7a30202, 0xb9a30202, 0xa4a30202, 0xdaa30202, 0xaaa30202, 0xdea30202, 0xe0a30202, + 0xdfa30202, 0xaca30202, 0xbea30202, 0xbfa30202, 0xaea30202, 0xc0a30202, 0x9ea30202, 0xdda30202, + 0xdba30202, 0xbaa30202, 0xdca30202, 0xa6a30202, 0xaba30202, 0xe1a30202, 0xada30202, 0xbba30202, + 0xe2a30202, 0xbda30202, 0xbca30202, 0xcfa30202, 0xd0a30202, 0xcea30202, 0xd2a30202, 0xd1a30202, + 0xd5a30202, 0x97a30202, 0xa5a30202, 0xd3a30202, 0xd4a30202, 0x9aa30202, 0xeca30202, 0xeda30202, + 0xeea30202, 0x9fa30202, 0xe5a30202, 0xe6a30202, 0xe7a30202, 0xe3a30202, 0xe4a30202, 0xa0a30202, + 0x030deb02, 0x1a0deb02, 0x1c0deb02, 0x1e0deb02, 0x200deb02, 0x220deb02, 0x240deb02, 0x260deb02, + 0x280deb02, 0x2a0deb02, 0x2c0deb02, 0x2d0deb02, 0x2e0deb02, 0x2f0deb02, 0x300deb02, 0x310deb02, + 0x320deb02, 0x330deb02, 0x340deb02, 0x350deb02, 0x360deb02, 0x370deb02, 0x380deb02, 0x390deb02, + 0x3a0deb02, 0x92a30202, 0x00000000, 0x00000000, 0x90a30202, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x3c056502, 0x3c056602, 0x3c056702, 0x3c056802, 0x3c056902, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x100e0202, 0x410e0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x420e0202, 0x5b0e0202, 0x290e0202, 0x9b0e0202, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x540e0202, + 0x550e0202, 0x00000000, 0x440e0202, 0x620e0202, 0x2a0e0202, 0x8e0e0202, 0x8f0e0202, 0x900e0202, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x060e0202, 0x00000000, 0x00000000, 0x00000000, 0x0f0e0202, 0x170e0202, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x4f0e0202, 0x00000000, 0x00000000, 0x5c0e0202, 0x610e0202, 0x00000000, + 0x830e0202, 0x840e0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8ea30202, 0x8da30202, + 0x1a0dee02, 0x1c0dee02, 0x1e0dee02, 0x200dee02, 0x220dee02, 0x240dee02, 0x260dee02, 0x280dee02, + 0x2a0dee02, 0x2c0dee02, 0x2d0dee02, 0x2e0dee02, 0x2f0dee02, 0x300dee02, 0x310dee02, 0x320dee02, + 0x330dee02, 0x340dee02, 0x350dee02, 0x360dee02, 0x370dee02, 0x380dee02, 0x390dee02, 0x3a0dee02, + 0x3b0dee02, 0x3c0dee02, 0x3d0dee02, 0x3e0dee02, 0x3f0dee02, 0x400dee02, 0x410dee02, 0x8fa30202, + 0x8f050202, 0x8f050302, 0x8f050402, 0x8f050502, 0x8f050602, 0x8f050702, 0x8f050802, 0x8f050902, + 0x8f050a02, 0x8f050b02, 0x8f050c02, 0x8f050d02, 0x8f050e02, 0x8f050f02, 0x8f051002, 0x8f051102, + 0x8f051202, 0x8f051302, 0x8f051402, 0x8f051502, 0x8f051602, 0x8f051702, 0x8f051802, 0x8f051902, + 0x8f051a02, 0x8f051b02, 0x8f051c02, 0x8f051d02, 0x8f051e02, 0x8f051f02, 0x8f052002, 0x8f052102, + 0x8f052202, 0x8f052302, 0x8f052402, 0x8f052502, 0x8f052602, 0x8f052702, 0x8f052802, 0x8f052902, + 0x8f052a02, 0x8f052b02, 0x8f052c02, 0x8f052d02, 0x8f052e02, 0x8f052f02, 0x8f053002, 0x8f053102, + 0x8f053202, 0x8f053302, 0x8f053402, 0x8f053502, 0x8f053602, 0x8f053702, 0x8f053802, 0x8f053902, + 0x8f053a02, 0x8f053b02, 0x8f053c02, 0x8f053d02, 0x8f053e02, 0x8f053f02, 0x8f054002, 0x8f054102, + 0x8f054202, 0x8f054302, 0x8f054402, 0x8f054502, 0x8f054602, 0x8f054702, 0x8f054802, 0x8f054902, + 0x8f054a02, 0x8f054b02, 0x8f054c02, 0x8f054d02, 0x8f054e02, 0x8f054f02, 0x8f055002, 0x8f055102, + 0x8f055202, 0x8f055302, 0x8f055402, 0x8f055502, 0x8f055602, 0x8f055702, 0x8f055802, 0x8f055902, + 0x8f055a02, 0x8f055b02, 0x8f055c02, 0x8f055d02, 0x8f055e02, 0x8f055f02, 0x8f056002, 0x8f056102, + 0x8f056202, 0x8f056302, 0x8f056402, 0x8f056502, 0x8f056602, 0x8f056702, 0x8f056802, 0x8f056902, + 0x8f056a02, 0x8f056b02, 0x8f056c02, 0x8f056d02, 0x8f056e02, 0x8f056f02, 0x8f057002, 0x8f057102, + 0x8f057202, 0x8f057302, 0x8f057402, 0x8f057502, 0x8f057602, 0x8f057702, 0x8f057802, 0x8f057902, + 0x8f057a02, 0x8f057b02, 0x8f057c02, 0x8f057d02, 0x8f057e02, 0x8f057f02, 0x8f058002, 0x8f058102, + 0x8f058202, 0x8f058302, 0x8f058402, 0x8f058502, 0x8f058602, 0x8f058702, 0x8f058802, 0x8f058902, + 0x8f058a02, 0x8f058b02, 0x8f058c02, 0x8f058d02, 0x8f058e02, 0x8f058f02, 0x8f059002, 0x8f059102, + 0x8f059202, 0x8f059302, 0x8f059402, 0x8f059502, 0x8f059602, 0x8f059702, 0x8f059802, 0x8f059902, + 0x8f059a02, 0x8f059b02, 0x8f059c02, 0x8f059d02, 0x8f059e02, 0x8f059f02, 0x8f05a002, 0x8f05a102, + 0x8f05a202, 0x8f05a302, 0x8f05a402, 0x8f05a502, 0x8f05a602, 0x8f05a702, 0x8f05a802, 0x8f05a902, + 0x8f05aa02, 0x8f05ab02, 0x8f05ac02, 0x8f05ad02, 0x8f05ae02, 0x8f05af02, 0x8f05b002, 0x8f05b102, + 0x8f05b202, 0x8f05b302, 0x8f05b402, 0x8f05b502, 0x8f05b602, 0x8f05b702, 0x8f05b802, 0x8f05b902, + 0x8f05ba02, 0x8f05bb02, 0x8f05bc02, 0x8f05bd02, 0x8f05be02, 0x8f05bf02, 0x8f05c002, 0x8f05c102, + 0x8f05c202, 0x8f05c302, 0x8f05c402, 0x8f05c502, 0x8f05c602, 0x8f05c702, 0x8f05c802, 0x8f05c902, + 0x8f05ca02, 0x8f05cb02, 0x8f05cc02, 0x8f05cd02, 0x8f05ce02, 0x8f05cf02, 0x8f05d002, 0x8f05d102, + 0x8f05d202, 0x8f05d302, 0x8f05d402, 0x8f05d502, 0x8f05d602, 0x8f05d702, 0x8f05d802, 0x8f05d902, + 0x8f05da02, 0x8f05db02, 0x8f05dc02, 0x8f05dd02, 0x8f05de02, 0x8f05df02, 0x8f05e002, 0x8f05e102, + 0x8f05e202, 0x8f05e302, 0x8f05e402, 0x8f05e502, 0x8f05e602, 0x8f05e702, 0x8f05e802, 0x8f05e902, + 0x8f05ea02, 0x8f05eb02, 0x8f05ec02, 0x8f05ed02, 0x8f05ee02, 0x8f05ef02, 0x8f05f002, 0x8f05f102, + 0x8f05f202, 0x8f05f302, 0x8f05f402, 0x8f05f502, 0x8f05f602, 0x8f05f702, 0x8f05f802, 0x8f05f902, + 0x8f05fa02, 0x8f05fb02, 0x8f05fc02, 0x8f05fd02, 0x8f05fe02, 0x8f05ff02, 0x90050202, 0x90050302, + 0x90050402, 0x90050502, 0x90050602, 0x90050702, 0x90050802, 0x90050902, 0x90050a02, 0x90050b02, + 0x90050c02, 0x90050d02, 0x90050e02, 0x90050f02, 0x90051002, 0x90051102, 0x90051202, 0x90051302, + 0x90051402, 0x90051502, 0x90051602, 0x90051702, 0x90051802, 0x90051902, 0x90051a02, 0x90051b02, + 0x90051c02, 0x90051d02, 0x90051e02, 0x90051f02, 0x90052002, 0x90052102, 0x90052202, 0x90052302, + 0x90052402, 0x90052502, 0x90052602, 0x90052702, 0x90052802, 0x90052902, 0x90052a02, 0x90052b02, + 0x90052c02, 0x90052d02, 0x90052e02, 0x90052f02, 0x90053002, 0x90053102, 0x90053202, 0x90053302, + 0x90053402, 0x90053502, 0x90053602, 0x90053702, 0x90053802, 0x90053902, 0x90053a02, 0x90053b02, + 0x90053c02, 0x90053d02, 0x90053e02, 0x90053f02, 0x90054002, 0x90054102, 0x90054202, 0x90054302, + 0x90054402, 0x90054502, 0x90054602, 0x90054702, 0x90054802, 0x90054902, 0x90054a02, 0x90054b02, + 0x90054c02, 0x90054d02, 0x90054e02, 0x90054f02, 0x90055002, 0x90055102, 0x90055202, 0x90055302, + 0x90055402, 0x90055502, 0x90055602, 0x90055702, 0x90055802, 0x90055902, 0x90055a02, 0x90055b02, + 0x90055c02, 0x90055d02, 0x90055e02, 0x90055f02, 0x90056002, 0x90056102, 0x90056202, 0x90056302, + 0x90056402, 0x90056502, 0x90056602, 0x90056702, 0x90056802, 0x90056902, 0x90056a02, 0x90056b02, + 0x90056c02, 0x90056d02, 0x90056e02, 0x90056f02, 0x90057002, 0x90057102, 0x90057202, 0x90057302, + 0x90057402, 0x90057502, 0x90057602, 0x90057702, 0x90057802, 0x90057902, 0x90057a02, 0x90057b02, + 0x90057c02, 0x90057d02, 0x90057e02, 0x90057f02, 0x90058002, 0x90058102, 0x90058202, 0x90058302, + 0x90058402, 0x90058502, 0x90058602, 0x90058702, 0x90058802, 0x90058902, 0x90058a02, 0x90058b02, + 0x90058c02, 0x90058d02, 0x90058e02, 0x90058f02, 0x90059002, 0x90059102, 0x90059202, 0x90059302, + 0x90059402, 0x90059502, 0x90059602, 0x90059702, 0x90059802, 0x90059902, 0x90059a02, 0x90059b02, + 0x90059c02, 0x90059d02, 0x90059e02, 0x90059f02, 0x9005a002, 0x9005a102, 0x9005a202, 0x9005a302, + 0x9005a402, 0x9005a502, 0x9005a602, 0x9005a702, 0x9005a802, 0x9005a902, 0x9005aa02, 0x9005ab02, + 0x9005ac02, 0x9005ad02, 0x9005ae02, 0x9005af02, 0x9005b002, 0x9005b102, 0x9005b202, 0x9005b302, + 0x9005b402, 0x9005b502, 0x9005b602, 0x9005b702, 0x9005b802, 0x9005b902, 0x9005ba02, 0x9005bb02, + 0x9005bc02, 0x9005bd02, 0x9005be02, 0x9005bf02, 0x9005c002, 0x9005c102, 0x9005c202, 0x9005c302, + 0x9005c402, 0x9005c502, 0x9005c602, 0x9005c702, 0x9005c802, 0x9005c902, 0x9005ca02, 0x9005cb02, + 0x9005cc02, 0x9005cd02, 0x9005ce02, 0x9005cf02, 0x9005d002, 0x9005d102, 0x9005d202, 0x9005d302, + 0x9005d402, 0x9005d502, 0x9005d602, 0x9005d702, 0x9005d802, 0x9005d902, 0x9005da02, 0x9005db02, + 0x9005dc02, 0x9005dd02, 0x9005de02, 0x9005df02, 0x9005e002, 0x9005e102, 0x9005e202, 0x9005e302, + 0x9005e402, 0x9005e502, 0x9005e602, 0x9005e702, 0x9005e802, 0x9005e902, 0x9005ea02, 0x9005eb02, + 0x9005ec02, 0x9005ed02, 0x9005ee02, 0x9005ef02, 0x9005f002, 0x9005f102, 0x9005f202, 0x9005f302, + 0x9005f402, 0x9005f502, 0x9005f602, 0x9005f702, 0x9005f802, 0x9005f902, 0x9005fa02, 0x9005fb02, + 0x9005fc02, 0x9005fd02, 0x9005fe02, 0x9005ff02, 0x91050202, 0x91050302, 0x91050402, 0x91050502, + 0x91050602, 0x91050702, 0x91050802, 0x91050902, 0x91050a02, 0x91050b02, 0x91050c02, 0x91050d02, + 0x91050e02, 0x91050f02, 0x91051002, 0x91051102, 0x91051202, 0x91051302, 0x91051402, 0x91051502, + 0x91051602, 0x91051702, 0x91051802, 0x91051902, 0x91051a02, 0x91051b02, 0x91051c02, 0x91051d02, + 0x91051e02, 0x91051f02, 0x91052002, 0x91052102, 0x91052202, 0x91052302, 0x91052402, 0x91052502, + 0x91052602, 0x91052702, 0x91052802, 0x91052902, 0x91052a02, 0x91052b02, 0x91052c02, 0x91052d02, + 0x91052e02, 0x91052f02, 0x91053002, 0x91053102, 0x91053202, 0x91053302, 0x91053402, 0x91053502, + 0x91053602, 0x91053702, 0x91053802, 0x91053902, 0x91053a02, 0x91053b02, 0x91053c02, 0x91053d02, + 0x91053e02, 0x91053f02, 0x91054002, 0x91054102, 0x91054202, 0x91054302, 0x91054402, 0x91054502, + 0x91054602, 0x91054702, 0x91054802, 0x91054902, 0x91054a02, 0x91054b02, 0x91054c02, 0x91054d02, + 0x91054e02, 0x91054f02, 0x91055002, 0x91055102, 0x91055202, 0x91055302, 0x91055402, 0x91055502, + 0x91055602, 0x91055702, 0x91055802, 0x91055902, 0x91055a02, 0x91055b02, 0x91055c02, 0x91055d02, + 0x91055e02, 0x91055f02, 0x91056002, 0x91056102, 0x91056202, 0x91056302, 0x91056402, 0x91056502, + 0x91056602, 0x91056702, 0x91056802, 0x91056902, 0x91056a02, 0x91056b02, 0x91056c02, 0x91056d02, + 0x91056e02, 0x91056f02, 0x91057002, 0x91057102, 0x91057202, 0x91057302, 0x91057402, 0x91057502, + 0x91057602, 0x91057702, 0x91057802, 0x91057902, 0x91057a02, 0x91057b02, 0x91057c02, 0x91057d02, + 0x91057e02, 0x91057f02, 0x91058002, 0x91058102, 0x91058202, 0x91058302, 0x91058402, 0x91058502, + 0x91058602, 0x91058702, 0x91058802, 0x91058902, 0x91058a02, 0x91058b02, 0x91058c02, 0x91058d02, + 0x91058e02, 0x91058f02, 0x91059002, 0x91059102, 0x91059202, 0x91059302, 0x91059402, 0x91059502, + 0x91059602, 0x91059702, 0x91059802, 0x91059902, 0x91059a02, 0x91059b02, 0x91059c02, 0x91059d02, + 0x91059e02, 0x91059f02, 0x9105a002, 0x9105a102, 0x9105a202, 0x9105a302, 0x9105a402, 0x9105a502, + 0x9105a602, 0x9105a702, 0x9105a802, 0x9105a902, 0x9105aa02, 0x9105ab02, 0x9105ac02, 0x9105ad02, + 0x9105ae02, 0x9105af02, 0x9105b002, 0x9105b102, 0x9105b202, 0x9105b302, 0x9105b402, 0x9105b502, + 0x9105b602, 0x9105b702, 0x9105b802, 0x9105b902, 0x9105ba02, 0x9105bb02, 0x9105bc02, 0x9105bd02, + 0x9105be02, 0x9105bf02, 0x9105c002, 0x9105c102, 0x9105c202, 0x9105c302, 0x9105c402, 0x9105c502, + 0x9105c602, 0x9105c702, 0x9105c802, 0x9105c902, 0x9105ca02, 0x9105cb02, 0x9105cc02, 0x9105cd02, + 0x9105ce02, 0x9105cf02, 0x9105d002, 0x9105d102, 0x9105d202, 0x9105d302, 0x9105d402, 0x9105d502, + 0x9105d602, 0x9105d702, 0x9105d802, 0x9105d902, 0x9105da02, 0x9105db02, 0x9105dc02, 0x9105dd02, + 0x9105de02, 0x9105df02, 0x9105e002, 0x9105e102, 0x9105e202, 0x9105e302, 0x9105e402, 0x9105e502, + 0x9105e602, 0x9105e702, 0x9105e802, 0x9105e902, 0x9105ea02, 0x9105eb02, 0x9105ec02, 0x9105ed02, + 0x9105ee02, 0x9105ef02, 0x9105f002, 0x9105f102, 0x9105f202, 0x9105f302, 0x9105f402, 0x9105f502, + 0x9105f602, 0x9105f702, 0x9105f802, 0x9105f902, 0x9105fa02, 0x9105fb02, 0x9105fc02, 0x9105fd02, + 0x9105fe02, 0x9105ff02, 0x92050202, 0x92050302, 0x92050402, 0x92050502, 0x92050602, 0x92050702, + 0x92050802, 0x92050902, 0x92050a02, 0x92050b02, 0x92050c02, 0x92050d02, 0x92050e02, 0x92050f02, + 0x92051002, 0x92051102, 0x92051202, 0x92051302, 0x92051402, 0x92051502, 0x92051602, 0x92051702, + 0x92051802, 0x92051902, 0x92051a02, 0x92051b02, 0x92051c02, 0x92051d02, 0x92051e02, 0x92051f02, + 0x92052002, 0x92052102, 0x92052202, 0x92052302, 0x92052402, 0x92052502, 0x92052602, 0x92052702, + 0x92052802, 0x92052902, 0x92052a02, 0x92052b02, 0x92052c02, 0x92052d02, 0x92052e02, 0x92052f02, + 0x92053002, 0x92053102, 0x92053202, 0x92053302, 0x92053402, 0x92053502, 0x92053602, 0x92053702, + 0x92053802, 0x92053902, 0x92053a02, 0x92053b02, 0x92053c02, 0x92053d02, 0x92053e02, 0x92053f02, + 0x92054002, 0x92054102, 0x92054202, 0x92054302, 0x92054402, 0x92054502, 0x92054602, 0x92054702, + 0x92054802, 0x92054902, 0x92054a02, 0x92054b02, 0x92054c02, 0x92054d02, 0x92054e02, 0x92054f02, + 0x92055002, 0x92055102, 0x92055202, 0x92055302, 0x92055402, 0x92055502, 0x92055602, 0x92055702, + 0x92055802, 0x92055902, 0x92055a02, 0x92055b02, 0x92055c02, 0x92055d02, 0x92055e02, 0x92055f02, + 0x92056002, 0x92056102, 0x92056202, 0x92056302, 0x92056402, 0x92056502, 0x92056602, 0x92056702, + 0x92056802, 0x92056902, 0x92056a02, 0x92056b02, 0x92056c02, 0x92056d02, 0x92056e02, 0x92056f02, + 0x92057002, 0x92057102, 0x92057202, 0x92057302, 0x92057402, 0x92057502, 0x92057602, 0x92057702, + 0x92057802, 0x92057902, 0x92057a02, 0x92057b02, 0x92057c02, 0x92057d02, 0x92057e02, 0x92057f02, + 0x92058002, 0x92058102, 0x92058202, 0x92058302, 0x92058402, 0x92058502, 0x92058602, 0x92058702, + 0x92058802, 0x92058902, 0x92058a02, 0x92058b02, 0x92058c02, 0x92058d02, 0x92058e02, 0x92058f02, + 0x92059002, 0x92059102, 0x92059202, 0x92059302, 0x92059402, 0x92059502, 0x92059602, 0x92059702, + 0x92059802, 0x92059902, 0x92059a02, 0x92059b02, 0x92059c02, 0x92059d02, 0x92059e02, 0x92059f02, + 0x9205a002, 0x9205a102, 0x9205a202, 0x9205a302, 0x9205a402, 0x9205a502, 0x9205a602, 0x9205a702, + 0x9205a802, 0x9205a902, 0x9205aa02, 0x9205ab02, 0x9205ac02, 0x9205ad02, 0x9205ae02, 0x9205af02, + 0x9205b002, 0x9205b102, 0x9205b202, 0x9205b302, 0x9205b402, 0x9205b502, 0x9205b602, 0x9205b702, + 0x9205b802, 0x9205b902, 0x9205ba02, 0x9205bb02, 0x9205bc02, 0x9205bd02, 0x9205be02, 0x9205bf02, + 0x9205c002, 0x9205c102, 0x9205c202, 0x9205c302, 0x9205c402, 0x9205c502, 0x9205c602, 0x9205c702, + 0x9205c802, 0x9205c902, 0x9205ca02, 0x9205cb02, 0x9205cc02, 0x9205cd02, 0x9205ce02, 0x9205cf02, + 0x9205d002, 0x9205d102, 0x9205d202, 0x9205d302, 0x9205d402, 0x9205d502, 0x9205d602, 0x9205d702, + 0x9205d802, 0x9205d902, 0x9205da02, 0x9205db02, 0x9205dc02, 0x9205dd02, 0x9205de02, 0x9205df02, + 0x9205e002, 0x9205e102, 0x9205e202, 0x9205e302, 0x9205e402, 0x9205e502, 0x9205e602, 0x9205e702, + 0x9205e802, 0x9205e902, 0x9205ea02, 0x9205eb02, 0x9205ec02, 0x9205ed02, 0x9205ee02, 0x9205ef02, + 0x9205f002, 0x9205f102, 0x9205f202, 0x9205f302, 0x9205f402, 0x9205f502, 0x9205f602, 0x9205f702, + 0x9205f802, 0x9205f902, 0x9205fa02, 0x9205fb02, 0x9205fc02, 0x9205fd02, 0x9205fe02, 0x9205ff02, + 0x93050202, 0x93050302, 0x93050402, 0x93050502, 0x93050602, 0x93050702, 0x93050802, 0x93050902, + 0x93050a02, 0x93050b02, 0x93050c02, 0x93050d02, 0x93050e02, 0x93050f02, 0x93051002, 0x93051102, + 0x93051202, 0x93051302, 0x93051402, 0x93051502, 0x93051602, 0x93051702, 0x93051802, 0x93051902, + 0x93051a02, 0x93051b02, 0x93051c02, 0x93051d02, 0x93051e02, 0x93051f02, 0x93052002, 0x93052102, + 0x93052202, 0x93052302, 0x93052402, 0x93052502, 0x93052602, 0x93052702, 0x93052802, 0x93052902, + 0x93052a02, 0x93052b02, 0x93052c02, 0x93052d02, 0x93052e02, 0x93052f02, 0x93053002, 0x93053102, + 0x93053202, 0x93053302, 0x93053402, 0x93053502, 0x93053602, 0x93053702, 0x93053802, 0x93053902, + 0x93053a02, 0x93053b02, 0x93053c02, 0x93053d02, 0x93053e02, 0x93053f02, 0x93054002, 0x93054102, + 0x93054202, 0x93054302, 0x93054402, 0x93054502, 0x93054602, 0x93054702, 0x93054802, 0x93054902, + 0x93054a02, 0x93054b02, 0x93054c02, 0x93054d02, 0x93054e02, 0x93054f02, 0x93055002, 0x93055102, + 0x93055202, 0x93055302, 0x93055402, 0x93055502, 0x93055602, 0x93055702, 0x93055802, 0x93055902, + 0x93055a02, 0x93055b02, 0x93055c02, 0x93055d02, 0x93055e02, 0x93055f02, 0x93056002, 0x93056102, + 0x93056202, 0x93056302, 0x93056402, 0x93056502, 0x93056602, 0x93056702, 0x93056802, 0x93056902, + 0x93056a02, 0x93056b02, 0x93056c02, 0x93056d02, 0x93056e02, 0x93056f02, 0x93057002, 0x93057102, + 0x93057202, 0x93057302, 0x93057402, 0x93057502, 0x93057602, 0x93057702, 0x93057802, 0x93057902, + 0x93057a02, 0x93057b02, 0x93057c02, 0x93057d02, 0x93057e02, 0x93057f02, 0x93058002, 0x93058102, + 0x93058202, 0x93058302, 0x93058402, 0x93058502, 0x93058602, 0x93058702, 0x93058802, 0x93058902, + 0x93058a02, 0x93058b02, 0x93058c02, 0x93058d02, 0x93058e02, 0x93058f02, 0x93059002, 0x93059102, + 0x93059202, 0x93059302, 0x93059402, 0x93059502, 0x93059602, 0x93059702, 0x93059802, 0x93059902, + 0x93059a02, 0x93059b02, 0x93059c02, 0x93059d02, 0x93059e02, 0x93059f02, 0x9305a002, 0x9305a102, + 0x9305a202, 0x9305a302, 0x9305a402, 0x9305a502, 0x9305a602, 0x9305a702, 0x9305a802, 0x9305a902, + 0x9305aa02, 0x9305ab02, 0x9305ac02, 0x9305ad02, 0x9305ae02, 0x9305af02, 0x9305b002, 0x9305b102, + 0x9305b202, 0x9305b302, 0x9305b402, 0x9305b502, 0x9305b602, 0x9305b702, 0x9305b802, 0x9305b902, + 0x9305ba02, 0x9305bb02, 0x9305bc02, 0x9305bd02, 0x9305be02, 0x9305bf02, 0x9305c002, 0x9305c102, + 0x9305c202, 0x9305c302, 0x9305c402, 0x9305c502, 0x9305c602, 0x9305c702, 0x9305c802, 0x9305c902, + 0x9305ca02, 0x9305cb02, 0x9305cc02, 0x9305cd02, 0x9305ce02, 0x9305cf02, 0x9305d002, 0x9305d102, + 0x9305d202, 0x9305d302, 0x9305d402, 0x9305d502, 0x9305d602, 0x9305d702, 0x9305d802, 0x9305d902, + 0x9305da02, 0x9305db02, 0x9305dc02, 0x9305dd02, 0x9305de02, 0x9305df02, 0x9305e002, 0x9305e102, + 0x9305e202, 0x9305e302, 0x9305e402, 0x9305e502, 0x9305e602, 0x9305e702, 0x9305e802, 0x9305e902, + 0x9305ea02, 0x9305eb02, 0x9305ec02, 0x9305ed02, 0x9305ee02, 0x9305ef02, 0x9305f002, 0x9305f102, + 0x9305f202, 0x9305f302, 0x9305f402, 0x9305f502, 0x9305f602, 0x9305f702, 0x9305f802, 0x9305f902, + 0x9305fa02, 0x9305fb02, 0x9305fc02, 0x9305fd02, 0x9305fe02, 0x9305ff02, 0x94050202, 0x94050302, + 0x94050402, 0x94050502, 0x94050602, 0x94050702, 0x94050802, 0x94050902, 0x94050a02, 0x94050b02, + 0x94050c02, 0x94050d02, 0x94050e02, 0x94050f02, 0x94051002, 0x94051102, 0x94051202, 0x94051302, + 0x94051402, 0x94051502, 0x94051602, 0x94051702, 0x94051802, 0x94051902, 0x94051a02, 0x94051b02, + 0x94051c02, 0x94051d02, 0x94051e02, 0x94051f02, 0x94052002, 0x94052102, 0x94052202, 0x94052302, + 0x94052402, 0x94052502, 0x94052602, 0x94052702, 0x94052802, 0x94052902, 0x94052a02, 0x94052b02, + 0x94052c02, 0x94052d02, 0x94052e02, 0x94052f02, 0x94053002, 0x94053102, 0x94053202, 0x94053302, + 0x94053402, 0x94053502, 0x94053602, 0x94053702, 0x94053802, 0x94053902, 0x94053a02, 0x94053b02, + 0x94053c02, 0x94053d02, 0x94053e02, 0x94053f02, 0x94054002, 0x94054102, 0x94054202, 0x94054302, + 0x94054402, 0x94054502, 0x94054602, 0x94054702, 0x94054802, 0x94054902, 0x94054a02, 0x94054b02, + 0x94054c02, 0x94054d02, 0x94054e02, 0x94054f02, 0x94055002, 0x94055102, 0x94055202, 0x94055302, + 0x94055402, 0x94055502, 0x94055602, 0x94055702, 0x94055802, 0x94055902, 0x94055a02, 0x94055b02, + 0x94055c02, 0x94055d02, 0x94055e02, 0x94055f02, 0x94056002, 0x94056102, 0x94056202, 0x94056302, + 0x94056402, 0x94056502, 0x94056602, 0x94056702, 0x94056802, 0x94056902, 0x94056a02, 0x94056b02, + 0x94056c02, 0x94056d02, 0x94056e02, 0x94056f02, 0x94057002, 0x94057102, 0x94057202, 0x94057302, + 0x94057402, 0x94057502, 0x94057602, 0x94057702, 0x94057802, 0x94057902, 0x94057a02, 0x94057b02, + 0x94057c02, 0x94057d02, 0x94057e02, 0x94057f02, 0x94058002, 0x94058102, 0x94058202, 0x94058302, + 0x94058402, 0x94058502, 0x94058602, 0x94058702, 0x94058802, 0x94058902, 0x94058a02, 0x94058b02, + 0x94058c02, 0x94058d02, 0x94058e02, 0x94058f02, 0x94059002, 0x94059102, 0x94059202, 0x94059302, + 0x94059402, 0x94059502, 0x94059602, 0x94059702, 0x94059802, 0x94059902, 0x94059a02, 0x94059b02, + 0x94059c02, 0x94059d02, 0x94059e02, 0x94059f02, 0x9405a002, 0x9405a102, 0x9405a202, 0x9405a302, + 0x9405a402, 0x9405a502, 0x9405a602, 0x9405a702, 0x9405a802, 0x9405a902, 0x9405aa02, 0x9405ab02, + 0x9405ac02, 0x9405ad02, 0x9405ae02, 0x9405af02, 0x9405b002, 0x9405b102, 0x9405b202, 0x9405b302, + 0x9405b402, 0x9405b502, 0x9405b602, 0x9405b702, 0x9405b802, 0x9405b902, 0x9405ba02, 0x9405bb02, + 0x9405bc02, 0x9405bd02, 0x9405be02, 0x9405bf02, 0x9405c002, 0x9405c102, 0x9405c202, 0x9405c302, + 0x9405c402, 0x9405c502, 0x9405c602, 0x9405c702, 0x9405c802, 0x9405c902, 0x9405ca02, 0x9405cb02, + 0x9405cc02, 0x9405cd02, 0x9405ce02, 0x9405cf02, 0x9405d002, 0x9405d102, 0x9405d202, 0x9405d302, + 0x9405d402, 0x9405d502, 0x9405d602, 0x9405d702, 0x9405d802, 0x9405d902, 0x9405da02, 0x9405db02, + 0x9405dc02, 0x9405dd02, 0x9405de02, 0x9405df02, 0x9405e002, 0x9405e102, 0x9405e202, 0x9405e302, + 0x9405e402, 0x9405e502, 0x9405e602, 0x9405e702, 0x9405e802, 0x9405e902, 0x9405ea02, 0x9405eb02, + 0x9405ec02, 0x9405ed02, 0x9405ee02, 0x9405ef02, 0x9405f002, 0x9405f102, 0x9405f202, 0x9405f302, + 0x9405f402, 0x9405f502, 0x9405f602, 0x9405f702, 0x9405f802, 0x9405f902, 0x9405fa02, 0x9405fb02, + 0x9405fc02, 0x9405fd02, 0x9405fe02, 0x9405ff02, 0x95050202, 0x95050302, 0x95050402, 0x95050502, + 0x95050602, 0x95050702, 0x95050802, 0x95050902, 0x95050a02, 0x95050b02, 0x95050c02, 0x95050d02, + 0x95050e02, 0x95050f02, 0x95051002, 0x95051102, 0x95051202, 0x95051302, 0x95051402, 0x95051502, + 0x95051602, 0x95051702, 0x95051802, 0x95051902, 0x95051a02, 0x95051b02, 0x95051c02, 0x95051d02, + 0x95051e02, 0x95051f02, 0x95052002, 0x95052102, 0x95052202, 0x95052302, 0x95052402, 0x95052502, + 0x95052602, 0x95052702, 0x95052802, 0x95052902, 0x95052a02, 0x95052b02, 0x95052c02, 0x95052d02, + 0x95052e02, 0x95052f02, 0x95053002, 0x95053102, 0x95053202, 0x95053302, 0x95053402, 0x95053502, + 0x95053602, 0x95053702, 0x95053802, 0x95053902, 0x95053a02, 0x95053b02, 0x95053c02, 0x95053d02, + 0x95053e02, 0x95053f02, 0x95054002, 0x95054102, 0x95054202, 0x95054302, 0x95054402, 0x95054502, + 0x95054602, 0x95054702, 0x95054802, 0x95054902, 0x95054a02, 0x95054b02, 0x95054c02, 0x95054d02, + 0x95054e02, 0x95054f02, 0x95055002, 0x95055102, 0x95055202, 0x95055302, 0x95055402, 0x95055502, + 0x95055602, 0x95055702, 0x95055802, 0x95055902, 0x95055a02, 0x95055b02, 0x95055c02, 0x95055d02, + 0x95055e02, 0x95055f02, 0x95056002, 0x95056102, 0x95056202, 0x95056302, 0x95056402, 0x95056502, + 0x95056602, 0x95056702, 0x95056802, 0x95056902, 0x95056a02, 0x95056b02, 0x95056c02, 0x95056d02, + 0x95056e02, 0x95056f02, 0x95057002, 0x95057102, 0x95057202, 0x95057302, 0x95057402, 0x95057502, + 0x95057602, 0x95057702, 0x95057802, 0x95057902, 0x95057a02, 0x95057b02, 0x95057c02, 0x95057d02, + 0x95057e02, 0x95057f02, 0x95058002, 0x95058102, 0x95058202, 0x95058302, 0x95058402, 0x95058502, + 0x95058602, 0x95058702, 0x95058802, 0x95058902, 0x95058a02, 0x95058b02, 0x95058c02, 0x95058d02, + 0x95058e02, 0x95058f02, 0x95059002, 0x95059102, 0x95059202, 0x95059302, 0x95059402, 0x95059502, + 0x95059602, 0x95059702, 0x95059802, 0x95059902, 0x95059a02, 0x95059b02, 0x95059c02, 0x95059d02, + 0x95059e02, 0x95059f02, 0x9505a002, 0x9505a102, 0x9505a202, 0x9505a302, 0x9505a402, 0x9505a502, + 0x9505a602, 0x9505a702, 0x9505a802, 0x9505a902, 0x9505aa02, 0x9505ab02, 0x9505ac02, 0x9505ad02, + 0x9505ae02, 0x9505af02, 0x9505b002, 0x9505b102, 0x9505b202, 0x9505b302, 0x9505b402, 0x9505b502, + 0x9505b602, 0x9505b702, 0x9505b802, 0x9505b902, 0x9505ba02, 0x9505bb02, 0x9505bc02, 0x9505bd02, + 0x9505be02, 0x9505bf02, 0x9505c002, 0x9505c102, 0x9505c202, 0x9505c302, 0x9505c402, 0x9505c502, + 0x9505c602, 0x9505c702, 0x9505c802, 0x9505c902, 0x9505ca02, 0x9505cb02, 0x9505cc02, 0x9505cd02, + 0x9505ce02, 0x9505cf02, 0x9505d002, 0x9505d102, 0x9505d202, 0x9505d302, 0x9505d402, 0x9505d502, + 0x9505d602, 0x9505d702, 0x9505d802, 0x9505d902, 0x9505da02, 0x9505db02, 0x9505dc02, 0x9505dd02, + 0x9505de02, 0x9505df02, 0x9505e002, 0x9505e102, 0x9505e202, 0x9505e302, 0x9505e402, 0x9505e502, + 0x9505e602, 0x9505e702, 0x9505e802, 0x9505e902, 0x9505ea02, 0x9505eb02, 0x9505ec02, 0x9505ed02, + 0x9505ee02, 0x9505ef02, 0x9505f002, 0x9505f102, 0x9505f202, 0x9505f302, 0x9505f402, 0x9505f502, + 0x9505f602, 0x9505f702, 0x9505f802, 0x9505f902, 0x9505fa02, 0x9505fb02, 0x9505fc02, 0x9505fd02, + 0x9505fe02, 0x9505ff02, 0x96050202, 0x96050302, 0x96050402, 0x96050502, 0x96050602, 0x96050702, + 0x96050802, 0x96050902, 0x96050a02, 0x96050b02, 0x96050c02, 0x96050d02, 0x96050e02, 0x96050f02, + 0x96051002, 0x96051102, 0x96051202, 0x96051302, 0x96051402, 0x96051502, 0x96051602, 0x96051702, + 0x96051802, 0x96051902, 0x96051a02, 0x96051b02, 0x96051c02, 0x96051d02, 0x96051e02, 0x96051f02, + 0x96052002, 0x96052102, 0x96052202, 0x96052302, 0x96052402, 0x96052502, 0x96052602, 0x96052702, + 0x96052802, 0x96052902, 0x96052a02, 0x96052b02, 0x96052c02, 0x96052d02, 0x96052e02, 0x96052f02, + 0x96053002, 0x96053102, 0x96053202, 0x96053302, 0x96053402, 0x96053502, 0x96053602, 0x96053702, + 0x96053802, 0x96053902, 0x96053a02, 0x96053b02, 0x96053c02, 0x96053d02, 0x96053e02, 0x96053f02, + 0x96054002, 0x96054102, 0x96054202, 0x96054302, 0x96054402, 0x96054502, 0x96054602, 0x96054702, + 0x96054802, 0x96054902, 0x96054a02, 0x96054b02, 0x96054c02, 0x96054d02, 0x96054e02, 0x96054f02, + 0x96055002, 0x96055102, 0x96055202, 0x96055302, 0x96055402, 0x96055502, 0x96055602, 0x96055702, + 0x96055802, 0x96055902, 0x96055a02, 0x96055b02, 0x96055c02, 0x96055d02, 0x96055e02, 0x96055f02, + 0x96056002, 0x96056102, 0x96056202, 0x96056302, 0x96056402, 0x96056502, 0x96056602, 0x96056702, + 0x96056802, 0x96056902, 0x96056a02, 0x96056b02, 0x96056c02, 0x96056d02, 0x96056e02, 0x96056f02, + 0x96057002, 0x96057102, 0x96057202, 0x96057302, 0x96057402, 0x96057502, 0x96057602, 0x96057702, + 0x96057802, 0x96057902, 0x96057a02, 0x96057b02, 0x96057c02, 0x96057d02, 0x96057e02, 0x96057f02, + 0x96058002, 0x96058102, 0x96058202, 0x96058302, 0x96058402, 0x96058502, 0x96058602, 0x96058702, + 0x96058802, 0x96058902, 0x96058a02, 0x96058b02, 0x96058c02, 0x96058d02, 0x96058e02, 0x96058f02, + 0x96059002, 0x96059102, 0x96059202, 0x96059302, 0x96059402, 0x96059502, 0x96059602, 0x96059702, + 0x96059802, 0x96059902, 0x96059a02, 0x96059b02, 0x96059c02, 0x96059d02, 0x96059e02, 0x96059f02, + 0x9605a002, 0x9605a102, 0x9605a202, 0x9605a302, 0x9605a402, 0x9605a502, 0x9605a602, 0x9605a702, + 0x9605a802, 0x9605a902, 0x9605aa02, 0x9605ab02, 0x9605ac02, 0x9605ad02, 0x9605ae02, 0x9605af02, + 0x9605b002, 0x9605b102, 0x9605b202, 0x9605b302, 0x9605b402, 0x9605b502, 0x9605b602, 0x9605b702, + 0x9605b802, 0x9605b902, 0x9605ba02, 0x9605bb02, 0x9605bc02, 0x9605bd02, 0x9605be02, 0x9605bf02, + 0x9605c002, 0x9605c102, 0x9605c202, 0x9605c302, 0x9605c402, 0x9605c502, 0x9605c602, 0x9605c702, + 0x9605c802, 0x9605c902, 0x9605ca02, 0x9605cb02, 0x9605cc02, 0x9605cd02, 0x9605ce02, 0x9605cf02, + 0x9605d002, 0x9605d102, 0x9605d202, 0x9605d302, 0x9605d402, 0x9605d502, 0x9605d602, 0x9605d702, + 0x9605d802, 0x9605d902, 0x9605da02, 0x9605db02, 0x9605dc02, 0x9605dd02, 0x9605de02, 0x9605df02, + 0x9605e002, 0x9605e102, 0x9605e202, 0x9605e302, 0x9605e402, 0x9605e502, 0x9605e602, 0x9605e702, + 0x9605e802, 0x9605e902, 0x9605ea02, 0x9605eb02, 0x9605ec02, 0x9605ed02, 0x9605ee02, 0x9605ef02, + 0x9605f002, 0x9605f102, 0x9605f202, 0x9605f302, 0x9605f402, 0x9605f502, 0x9605f602, 0x9605f702, + 0x9605f802, 0x9605f902, 0x9605fa02, 0x9605fb02, 0x9605fc02, 0x9605fd02, 0x9605fe02, 0x9605ff02, + 0x97050202, 0x97050302, 0x97050402, 0x97050502, 0x97050602, 0x97050702, 0x97050802, 0x97050902, + 0x97050a02, 0x97050b02, 0x97050c02, 0x97050d02, 0x97050e02, 0x97050f02, 0x97051002, 0x97051102, + 0x97051202, 0x97051302, 0x97051402, 0x97051502, 0x97051602, 0x97051702, 0x97051802, 0x97051902, + 0x97051a02, 0x97051b02, 0x97051c02, 0x97051d02, 0x97051e02, 0x97051f02, 0x97052002, 0x97052102, + 0x97052202, 0x97052302, 0x97052402, 0x97052502, 0x97052602, 0x97052702, 0x97052802, 0x97052902, + 0x97052a02, 0x97052b02, 0x97052c02, 0x97052d02, 0x97052e02, 0x97052f02, 0x97053002, 0x97053102, + 0x97053202, 0x97053302, 0x97053402, 0x97053502, 0x97053602, 0x97053702, 0x97053802, 0x97053902, + 0x97053a02, 0x97053b02, 0x97053c02, 0x97053d02, 0x97053e02, 0x97053f02, 0x97054002, 0x97054102, + 0x97054202, 0x97054302, 0x97054402, 0x97054502, 0x97054602, 0x97054702, 0x97054802, 0x97054902, + 0x97054a02, 0x97054b02, 0x97054c02, 0x97054d02, 0x97054e02, 0x97054f02, 0x97055002, 0x97055102, + 0x97055202, 0x97055302, 0x97055402, 0x97055502, 0x97055602, 0x97055702, 0x97055802, 0x97055902, + 0x97055a02, 0x97055b02, 0x97055c02, 0x97055d02, 0x97055e02, 0x97055f02, 0x97056002, 0x97056102, + 0x97056202, 0x97056302, 0x97056402, 0x97056502, 0x97056602, 0x97056702, 0x97056802, 0x97056902, + 0x97056a02, 0x97056b02, 0x97056c02, 0x97056d02, 0x97056e02, 0x97056f02, 0x97057002, 0x97057102, + 0x97057202, 0x97057302, 0x97057402, 0x97057502, 0x97057602, 0x97057702, 0x97057802, 0x97057902, + 0x97057a02, 0x97057b02, 0x97057c02, 0x97057d02, 0x97057e02, 0x97057f02, 0x97058002, 0x97058102, + 0x97058202, 0x97058302, 0x97058402, 0x97058502, 0x97058602, 0x97058702, 0x97058802, 0x97058902, + 0x97058a02, 0x97058b02, 0x97058c02, 0x97058d02, 0x97058e02, 0x97058f02, 0x97059002, 0x97059102, + 0x97059202, 0x97059302, 0x97059402, 0x97059502, 0x97059602, 0x97059702, 0x97059802, 0x97059902, + 0x97059a02, 0x97059b02, 0x97059c02, 0x97059d02, 0x97059e02, 0x97059f02, 0x9705a002, 0x9705a102, + 0x9705a202, 0x9705a302, 0x9705a402, 0x9705a502, 0x9705a602, 0x9705a702, 0x9705a802, 0x9705a902, + 0x9705aa02, 0x9705ab02, 0x9705ac02, 0x9705ad02, 0x9705ae02, 0x9705af02, 0x9705b002, 0x9705b102, + 0x9705b202, 0x9705b302, 0x9705b402, 0x9705b502, 0x9705b602, 0x9705b702, 0x9705b802, 0x9705b902, + 0x9705ba02, 0x9705bb02, 0x9705bc02, 0x9705bd02, 0x9705be02, 0x9705bf02, 0x9705c002, 0x9705c102, + 0x9705c202, 0x9705c302, 0x9705c402, 0x9705c502, 0x9705c602, 0x9705c702, 0x9705c802, 0x9705c902, + 0x9705ca02, 0x9705cb02, 0x9705cc02, 0x9705cd02, 0x9705ce02, 0x9705cf02, 0x9705d002, 0x9705d102, + 0x9705d202, 0x9705d302, 0x9705d402, 0x9705d502, 0x9705d602, 0x9705d702, 0x9705d802, 0x9705d902, + 0x9705da02, 0x9705db02, 0x9705dc02, 0x9705dd02, 0x9705de02, 0x9705df02, 0x9705e002, 0x9705e102, + 0x9705e202, 0x9705e302, 0x9705e402, 0x9705e502, 0x9705e602, 0x9705e702, 0x9705e802, 0x9705e902, + 0x9705ea02, 0x9705eb02, 0x9705ec02, 0x9705ed02, 0x9705ee02, 0x9705ef02, 0x9705f002, 0x9705f102, + 0x9705f202, 0x9705f302, 0x9705f402, 0x9705f502, 0x9705f602, 0x9705f702, 0x9705f802, 0x9705f902, + 0x9705fa02, 0x9705fb02, 0x9705fc02, 0x9705fd02, 0x9705fe02, 0x9705ff02, 0x98050202, 0x98050302, + 0x98050402, 0x98050502, 0x98050602, 0x98050702, 0x98050802, 0x98050902, 0x98050a02, 0x98050b02, + 0x98050c02, 0x98050d02, 0x98050e02, 0x98050f02, 0x98051002, 0x98051102, 0x98051202, 0x98051302, + 0x98051402, 0x98051502, 0x98051602, 0x98051702, 0x98051802, 0x98051902, 0x98051a02, 0x98051b02, + 0x98051c02, 0x98051d02, 0x98051e02, 0x98051f02, 0x98052002, 0x98052102, 0x98052202, 0x98052302, + 0x98052402, 0x98052502, 0x98052602, 0x98052702, 0x98052802, 0x98052902, 0x98052a02, 0x98052b02, + 0x98052c02, 0x98052d02, 0x98052e02, 0x98052f02, 0x98053002, 0x98053102, 0x98053202, 0x98053302, + 0x98053402, 0x98053502, 0x98053602, 0x98053702, 0x98053802, 0x98053902, 0x98053a02, 0x98053b02, + 0x98053c02, 0x98053d02, 0x98053e02, 0x98053f02, 0x98054002, 0x98054102, 0x98054202, 0x98054302, + 0x98054402, 0x98054502, 0x98054602, 0x98054702, 0x98054802, 0x98054902, 0x98054a02, 0x98054b02, + 0x98054c02, 0x98054d02, 0x98054e02, 0x98054f02, 0x98055002, 0x98055102, 0x98055202, 0x98055302, + 0x98055402, 0x98055502, 0x98055602, 0x98055702, 0x98055802, 0x98055902, 0x98055a02, 0x98055b02, + 0x98055c02, 0x98055d02, 0x98055e02, 0x98055f02, 0x98056002, 0x98056102, 0x98056202, 0x98056302, + 0x98056402, 0x98056502, 0x98056602, 0x98056702, 0x98056802, 0x98056902, 0x98056a02, 0x98056b02, + 0x98056c02, 0x98056d02, 0x98056e02, 0x98056f02, 0x98057002, 0x98057102, 0x98057202, 0x98057302, + 0x98057402, 0x98057502, 0x98057602, 0x98057702, 0x98057802, 0x98057902, 0x98057a02, 0x98057b02, + 0x98057c02, 0x98057d02, 0x98057e02, 0x98057f02, 0x98058002, 0x98058102, 0x98058202, 0x98058302, + 0x98058402, 0x98058502, 0x98058602, 0x98058702, 0x98058802, 0x98058902, 0x98058a02, 0x98058b02, + 0x98058c02, 0x98058d02, 0x98058e02, 0x98058f02, 0x98059002, 0x98059102, 0x98059202, 0x98059302, + 0x98059402, 0x98059502, 0x98059602, 0x98059702, 0x98059802, 0x98059902, 0x98059a02, 0x98059b02, + 0x98059c02, 0x98059d02, 0x98059e02, 0x98059f02, 0x9805a002, 0x9805a102, 0x9805a202, 0x9805a302, + 0x9805a402, 0x9805a502, 0x9805a602, 0x9805a702, 0x9805a802, 0x9805a902, 0x9805aa02, 0x9805ab02, + 0x9805ac02, 0x9805ad02, 0x9805ae02, 0x9805af02, 0x9805b002, 0x9805b102, 0x9805b202, 0x9805b302, + 0x9805b402, 0x9805b502, 0x9805b602, 0x9805b702, 0x9805b802, 0x9805b902, 0x9805ba02, 0x9805bb02, + 0x9805bc02, 0x9805bd02, 0x9805be02, 0x9805bf02, 0x9805c002, 0x9805c102, 0x9805c202, 0x9805c302, + 0x9805c402, 0x9805c502, 0x9805c602, 0x9805c702, 0x9805c802, 0x9805c902, 0x9805ca02, 0x9805cb02, + 0x9805cc02, 0x9805cd02, 0x9805ce02, 0x9805cf02, 0x9805d002, 0x9805d102, 0x9805d202, 0x9805d302, + 0x9805d402, 0x9805d502, 0x9805d602, 0x9805d702, 0x9805d802, 0x9805d902, 0x9805da02, 0x9805db02, + 0x9805dc02, 0x9805dd02, 0x9805de02, 0x9805df02, 0x9805e002, 0x9805e102, 0x9805e202, 0x9805e302, + 0x9805e402, 0x9805e502, 0x9805e602, 0x9805e702, 0x9805e802, 0x9805e902, 0x9805ea02, 0x9805eb02, + 0x9805ec02, 0x9805ed02, 0x9805ee02, 0x9805ef02, 0x9805f002, 0x9805f102, 0x9805f202, 0x9805f302, + 0x9805f402, 0x9805f502, 0x9805f602, 0x9805f702, 0x9805f802, 0x9805f902, 0x9805fa02, 0x9805fb02, + 0x9805fc02, 0x9805fd02, 0x9805fe02, 0x9805ff02, 0x99050202, 0x99050302, 0x99050402, 0x99050502, + 0x99050602, 0x99050702, 0x99050802, 0x99050902, 0x99050a02, 0x99050b02, 0x99050c02, 0x99050d02, + 0x99050e02, 0x99050f02, 0x99051002, 0x99051102, 0x99051202, 0x99051302, 0x99051402, 0x99051502, + 0x99051602, 0x99051702, 0x99051802, 0x99051902, 0x99051a02, 0x99051b02, 0x99051c02, 0x99051d02, + 0x99051e02, 0x99051f02, 0x99052002, 0x99052102, 0x99052202, 0x99052302, 0x99052402, 0x99052502, + 0x99052602, 0x99052702, 0x99052802, 0x99052902, 0x99052a02, 0x99052b02, 0x99052c02, 0x99052d02, + 0x99052e02, 0x99052f02, 0x99053002, 0x99053102, 0x99053202, 0x99053302, 0x99053402, 0x99053502, + 0x99053602, 0x99053702, 0x99053802, 0x99053902, 0x99053a02, 0x99053b02, 0x99053c02, 0x99053d02, + 0x99053e02, 0x99053f02, 0x99054002, 0x99054102, 0x99054202, 0x99054302, 0x99054402, 0x99054502, + 0x99054602, 0x99054702, 0x99054802, 0x99054902, 0x99054a02, 0x99054b02, 0x99054c02, 0x99054d02, + 0x99054e02, 0x99054f02, 0x99055002, 0x99055102, 0x99055202, 0x99055302, 0x99055402, 0x99055502, + 0x99055602, 0x99055702, 0x99055802, 0x99055902, 0x99055a02, 0x99055b02, 0x99055c02, 0x99055d02, + 0x99055e02, 0x99055f02, 0x99056002, 0x99056102, 0x99056202, 0x99056302, 0x99056402, 0x99056502, + 0x99056602, 0x99056702, 0x99056802, 0x99056902, 0x99056a02, 0x99056b02, 0x99056c02, 0x99056d02, + 0x99056e02, 0x99056f02, 0x99057002, 0x99057102, 0x99057202, 0x99057302, 0x99057402, 0x99057502, + 0x99057602, 0x99057702, 0x99057802, 0x99057902, 0x99057a02, 0x99057b02, 0x99057c02, 0x99057d02, + 0x99057e02, 0x99057f02, 0x99058002, 0x99058102, 0x99058202, 0x99058302, 0x99058402, 0x99058502, + 0x99058602, 0x99058702, 0x99058802, 0x99058902, 0x99058a02, 0x99058b02, 0x99058c02, 0x99058d02, + 0x99058e02, 0x99058f02, 0x99059002, 0x99059102, 0x99059202, 0x99059302, 0x99059402, 0x99059502, + 0x99059602, 0x99059702, 0x99059802, 0x99059902, 0x99059a02, 0x99059b02, 0x99059c02, 0x99059d02, + 0x99059e02, 0x99059f02, 0x9905a002, 0x9905a102, 0x9905a202, 0x9905a302, 0x9905a402, 0x9905a502, + 0x9905a602, 0x9905a702, 0x9905a802, 0x9905a902, 0x9905aa02, 0x9905ab02, 0x9905ac02, 0x9905ad02, + 0x9905ae02, 0x9905af02, 0x9905b002, 0x9905b102, 0x9905b202, 0x9905b302, 0x9905b402, 0x9905b502, + 0x9905b602, 0x9905b702, 0x9905b802, 0x9905b902, 0x9905ba02, 0x9905bb02, 0x9905bc02, 0x9905bd02, + 0x9905be02, 0x9905bf02, 0x9905c002, 0x9905c102, 0x9905c202, 0x9905c302, 0x9905c402, 0x9905c502, + 0x9905c602, 0x9905c702, 0x9905c802, 0x9905c902, 0x9905ca02, 0x9905cb02, 0x9905cc02, 0x9905cd02, + 0x9905ce02, 0x9905cf02, 0x9905d002, 0x9905d102, 0x9905d202, 0x9905d302, 0x9905d402, 0x9905d502, + 0x9905d602, 0x9905d702, 0x9905d802, 0x9905d902, 0x9905da02, 0x9905db02, 0x9905dc02, 0x9905dd02, + 0x9905de02, 0x9905df02, 0x9905e002, 0x9905e102, 0x9905e202, 0x9905e302, 0x9905e402, 0x9905e502, + 0x9905e602, 0x9905e702, 0x9905e802, 0x9905e902, 0x9905ea02, 0x9905eb02, 0x9905ec02, 0x9905ed02, + 0x9905ee02, 0x9905ef02, 0x9905f002, 0x9905f102, 0x9905f202, 0x9905f302, 0x9905f402, 0x9905f502, + 0x9905f602, 0x9905f702, 0x9905f802, 0x9905f902, 0x9905fa02, 0x9905fb02, 0x9905fc02, 0x9905fd02, + 0x9905fe02, 0x9905ff02, 0x9a050202, 0x9a050302, 0x9a050402, 0x9a050502, 0x9a050602, 0x9a050702, + 0x9a050802, 0x9a050902, 0x9a050a02, 0x9a050b02, 0x9a050c02, 0x9a050d02, 0x9a050e02, 0x9a050f02, + 0x9a051002, 0x9a051102, 0x9a051202, 0x9a051302, 0x9a051402, 0x9a051502, 0x9a051602, 0x9a051702, + 0x9a051802, 0x9a051902, 0x9a051a02, 0x9a051b02, 0x9a051c02, 0x9a051d02, 0x9a051e02, 0x9a051f02, + 0x9a052002, 0x9a052102, 0x9a052202, 0x9a052302, 0x9a052402, 0x9a052502, 0x9a052602, 0x9a052702, + 0x9a052802, 0x9a052902, 0x9a052a02, 0x9a052b02, 0x9a052c02, 0x9a052d02, 0x9a052e02, 0x9a052f02, + 0x9a053002, 0x9a053102, 0x9a053202, 0x9a053302, 0x9a053402, 0x9a053502, 0x9a053602, 0x9a053702, + 0x9a053802, 0x9a053902, 0x9a053a02, 0x9a053b02, 0x9a053c02, 0x9a053d02, 0x9a053e02, 0x9a053f02, + 0x9a054002, 0x9a054102, 0x9a054202, 0x9a054302, 0x9a054402, 0x9a054502, 0x9a054602, 0x9a054702, + 0x9a054802, 0x9a054902, 0x9a054a02, 0x9a054b02, 0x9a054c02, 0x9a054d02, 0x9a054e02, 0x9a054f02, + 0x9a055002, 0x9a055102, 0x9a055202, 0x9a055302, 0x9a055402, 0x9a055502, 0x9a055602, 0x9a055702, + 0x9a055802, 0x9a055902, 0x9a055a02, 0x9a055b02, 0x9a055c02, 0x9a055d02, 0x9a055e02, 0x9a055f02, + 0x9a056002, 0x9a056102, 0x9a056202, 0x9a056302, 0x9a056402, 0x9a056502, 0x9a056602, 0x9a056702, + 0x9a056802, 0x9a056902, 0x9a056a02, 0x9a056b02, 0x9a056c02, 0x9a056d02, 0x9a056e02, 0x9a056f02, + 0x9a057002, 0x9a057102, 0x9a057202, 0x9a057302, 0x9a057402, 0x9a057502, 0x9a057602, 0x9a057702, + 0x9a057802, 0x9a057902, 0x9a057a02, 0x9a057b02, 0x9a057c02, 0x9a057d02, 0x9a057e02, 0x9a057f02, + 0x9a058002, 0x9a058102, 0x9a058202, 0x9a058302, 0x9a058402, 0x9a058502, 0x9a058602, 0x9a058702, + 0x9a058802, 0x9a058902, 0x9a058a02, 0x9a058b02, 0x9a058c02, 0x9a058d02, 0x9a058e02, 0x9a058f02, + 0x9a059002, 0x9a059102, 0x9a059202, 0x9a059302, 0x9a059402, 0x9a059502, 0x9a059602, 0x9a059702, + 0x9a059802, 0x9a059902, 0x9a059a02, 0x9a059b02, 0x9a059c02, 0x9a059d02, 0x9a059e02, 0x9a059f02, + 0x9a05a002, 0x9a05a102, 0x9a05a202, 0x9a05a302, 0x9a05a402, 0x9a05a502, 0x9a05a602, 0x9a05a702, + 0x9a05a802, 0x9a05a902, 0x9a05aa02, 0x9a05ab02, 0x9a05ac02, 0x9a05ad02, 0x9a05ae02, 0x9a05af02, + 0x9a05b002, 0x9a05b102, 0x9a05b202, 0x9a05b302, 0x9a05b402, 0x9a05b502, 0x9a05b602, 0x9a05b702, + 0x9a05b802, 0x9a05b902, 0x9a05ba02, 0x9a05bb02, 0x9a05bc02, 0x9a05bd02, 0x9a05be02, 0x9a05bf02, + 0x9a05c002, 0x9a05c102, 0x9a05c202, 0x9a05c302, 0x9a05c402, 0x9a05c502, 0x9a05c602, 0x9a05c702, + 0x9a05c802, 0x9a05c902, 0x9a05ca02, 0x9a05cb02, 0x9a05cc02, 0x9a05cd02, 0x9a05ce02, 0x9a05cf02, + 0x9a05d002, 0x9a05d102, 0x9a05d202, 0x9a05d302, 0x9a05d402, 0x9a05d502, 0x9a05d602, 0x9a05d702, + 0x9a05d802, 0x9a05d902, 0x9a05da02, 0x9a05db02, 0x9a05dc02, 0x9a05dd02, 0x9a05de02, 0x9a05df02, + 0x9a05e002, 0x9a05e102, 0x9a05e202, 0x9a05e302, 0x9a05e402, 0x9a05e502, 0x9a05e602, 0x9a05e702, + 0x9a05e802, 0x9a05e902, 0x9a05ea02, 0x9a05eb02, 0x9a05ec02, 0x9a05ed02, 0x9a05ee02, 0x9a05ef02, + 0x9a05f002, 0x9a05f102, 0x9a05f202, 0x9a05f302, 0x9a05f402, 0x9a05f502, 0x9a05f602, 0x9a05f702, + 0x9a05f802, 0x9a05f902, 0x9a05fa02, 0x9a05fb02, 0x9a05fc02, 0x9a05fd02, 0x9a05fe02, 0x9a05ff02, + 0x9b050202, 0x9b050302, 0x9b050402, 0x9b050502, 0x9b050602, 0x9b050702, 0x9b050802, 0x9b050902, + 0x9b050a02, 0x9b050b02, 0x9b050c02, 0x9b050d02, 0x9b050e02, 0x9b050f02, 0x9b051002, 0x9b051102, + 0x9b051202, 0x9b051302, 0x9b051402, 0x9b051502, 0x9b051602, 0x9b051702, 0x9b051802, 0x9b051902, + 0x9b051a02, 0x9b051b02, 0x9b051c02, 0x9b051d02, 0x9b051e02, 0x9b051f02, 0x9b052002, 0x9b052102, + 0x9b052202, 0x9b052302, 0x9b052402, 0x9b052502, 0x9b052602, 0x9b052702, 0x9b052802, 0x9b052902, + 0x9b052a02, 0x9b052b02, 0x9b052c02, 0x9b052d02, 0x9b052e02, 0x9b052f02, 0x9b053002, 0x9b053102, + 0x9b053202, 0x9b053302, 0x9b053402, 0x9b053502, 0x9b053602, 0x9b053702, 0x9b053802, 0x9b053902, + 0x9b053a02, 0x9b053b02, 0x9b053c02, 0x9b053d02, 0x9b053e02, 0x9b053f02, 0x9b054002, 0x9b054102, + 0x9b054202, 0x9b054302, 0x9b054402, 0x9b054502, 0x9b054602, 0x9b054702, 0x9b054802, 0x9b054902, + 0x9b054a02, 0x9b054b02, 0x9b054c02, 0x9b054d02, 0x9b054e02, 0x9b054f02, 0x9b055002, 0x9b055102, + 0x9b055202, 0x9b055302, 0x9b055402, 0x9b055502, 0x9b055602, 0x9b055702, 0x9b055802, 0x9b055902, + 0x9b055a02, 0x9b055b02, 0x9b055c02, 0x9b055d02, 0x9b055e02, 0x9b055f02, 0x9b056002, 0x9b056102, + 0x9b056202, 0x9b056302, 0x9b056402, 0x9b056502, 0x9b056602, 0x9b056702, 0x9b056802, 0x9b056902, + 0x9b056a02, 0x9b056b02, 0x9b056c02, 0x9b056d02, 0x9b056e02, 0x9b056f02, 0x9b057002, 0x9b057102, + 0x9b057202, 0x9b057302, 0x9b057402, 0x9b057502, 0x9b057602, 0x9b057702, 0x9b057802, 0x9b057902, + 0x9b057a02, 0x9b057b02, 0x9b057c02, 0x9b057d02, 0x9b057e02, 0x9b057f02, 0x9b058002, 0x9b058102, + 0x9b058202, 0x9b058302, 0x9b058402, 0x9b058502, 0x9b058602, 0x9b058702, 0x9b058802, 0x9b058902, + 0x9b058a02, 0x9b058b02, 0x9b058c02, 0x9b058d02, 0x9b058e02, 0x9b058f02, 0x9b059002, 0x9b059102, + 0x9b059202, 0x9b059302, 0x9b059402, 0x9b059502, 0x9b059602, 0x9b059702, 0x9b059802, 0x9b059902, + 0x9b059a02, 0x9b059b02, 0x9b059c02, 0x9b059d02, 0x9b059e02, 0x9b059f02, 0x9b05a002, 0x9b05a102, + 0x9b05a202, 0x9b05a302, 0x9b05a402, 0x9b05a502, 0x9b05a602, 0x9b05a702, 0x9b05a802, 0x9b05a902, + 0x9b05aa02, 0x9b05ab02, 0x9b05ac02, 0x9b05ad02, 0x9b05ae02, 0x9b05af02, 0x9b05b002, 0x9b05b102, + 0x9b05b202, 0x9b05b302, 0x9b05b402, 0x9b05b502, 0x9b05b602, 0x9b05b702, 0x9b05b802, 0x9b05b902, + 0x9b05ba02, 0x9b05bb02, 0x9b05bc02, 0x9b05bd02, 0x9b05be02, 0x9b05bf02, 0x9b05c002, 0x9b05c102, + 0x9b05c202, 0x9b05c302, 0x9b05c402, 0x9b05c502, 0x9b05c602, 0x9b05c702, 0x9b05c802, 0x9b05c902, + 0x9b05ca02, 0x9b05cb02, 0x9b05cc02, 0x9b05cd02, 0x9b05ce02, 0x9b05cf02, 0x9b05d002, 0x9b05d102, + 0x9b05d202, 0x9b05d302, 0x9b05d402, 0x9b05d502, 0x9b05d602, 0x9b05d702, 0x9b05d802, 0x9b05d902, + 0x9b05da02, 0x9b05db02, 0x9b05dc02, 0x9b05dd02, 0x9b05de02, 0x9b05df02, 0x9b05e002, 0x9b05e102, + 0x9b05e202, 0x9b05e302, 0x9b05e402, 0x9b05e502, 0x9b05e602, 0x9b05e702, 0x9b05e802, 0x9b05e902, + 0x9b05ea02, 0x9b05eb02, 0x9b05ec02, 0x9b05ed02, 0x9b05ee02, 0x9b05ef02, 0x9b05f002, 0x9b05f102, + 0x9b05f202, 0x9b05f302, 0x9b05f402, 0x9b05f502, 0x9b05f602, 0x9b05f702, 0x9b05f802, 0x9b05f902, + 0x9b05fa02, 0x9b05fb02, 0x9b05fc02, 0x9b05fd02, 0x9b05fe02, 0x9b05ff02, 0x9c050202, 0x9c050302, + 0x9c050402, 0x9c050502, 0x9c050602, 0x9c050702, 0x9c050802, 0x9c050902, 0x9c050a02, 0x9c050b02, + 0x9c050c02, 0x9c050d02, 0x9c050e02, 0x9c050f02, 0x9c051002, 0x9c051102, 0x9c051202, 0x9c051302, + 0x9c051402, 0x9c051502, 0x9c051602, 0x9c051702, 0x9c051802, 0x9c051902, 0x9c051a02, 0x9c051b02, + 0x9c051c02, 0x9c051d02, 0x9c051e02, 0x9c051f02, 0x9c052002, 0x9c052102, 0x9c052202, 0x9c052302, + 0x9c052402, 0x9c052502, 0x9c052602, 0x9c052702, 0x9c052802, 0x9c052902, 0x9c052a02, 0x9c052b02, + 0x9c052c02, 0x9c052d02, 0x9c052e02, 0x9c052f02, 0x9c053002, 0x9c053102, 0x9c053202, 0x9c053302, + 0x9c053402, 0x9c053502, 0x9c053602, 0x9c053702, 0x9c053802, 0x9c053902, 0x9c053a02, 0x9c053b02, + 0x9c053c02, 0x9c053d02, 0x9c053e02, 0x9c053f02, 0x9c054002, 0x9c054102, 0x9c054202, 0x9c054302, + 0x9c054402, 0x9c054502, 0x9c054602, 0x9c054702, 0x9c054802, 0x9c054902, 0x9c054a02, 0x9c054b02, + 0x9c054c02, 0x9c054d02, 0x9c054e02, 0x9c054f02, 0x9c055002, 0x9c055102, 0x9c055202, 0x9c055302, + 0x9c055402, 0x9c055502, 0x9c055602, 0x9c055702, 0x9c055802, 0x9c055902, 0x9c055a02, 0x9c055b02, + 0x9c055c02, 0x9c055d02, 0x9c055e02, 0x9c055f02, 0x9c056002, 0x9c056102, 0x9c056202, 0x9c056302, + 0x9c056402, 0x9c056502, 0x9c056602, 0x9c056702, 0x9c056802, 0x9c056902, 0x9c056a02, 0x9c056b02, + 0x9c056c02, 0x9c056d02, 0x9c056e02, 0x9c056f02, 0x9c057002, 0x9c057102, 0x9c057202, 0x9c057302, + 0x9c057402, 0x9c057502, 0x9c057602, 0x9c057702, 0x9c057802, 0x9c057902, 0x9c057a02, 0x9c057b02, + 0x9c057c02, 0x9c057d02, 0x9c057e02, 0x9c057f02, 0x9c058002, 0x9c058102, 0x9c058202, 0x9c058302, + 0x9c058402, 0x9c058502, 0x9c058602, 0x9c058702, 0x9c058802, 0x9c058902, 0x9c058a02, 0x9c058b02, + 0x9c058c02, 0x9c058d02, 0x9c058e02, 0x9c058f02, 0x9c059002, 0x9c059102, 0x9c059202, 0x9c059302, + 0x9c059402, 0x9c059502, 0x9c059602, 0x9c059702, 0x9c059802, 0x9c059902, 0x9c059a02, 0x9c059b02, + 0x9c059c02, 0x9c059d02, 0x9c059e02, 0x9c059f02, 0x9c05a002, 0x9c05a102, 0x9c05a202, 0x9c05a302, + 0x9c05a402, 0x9c05a502, 0x9c05a602, 0x9c05a702, 0x9c05a802, 0x9c05a902, 0x9c05aa02, 0x9c05ab02, + 0x9c05ac02, 0x9c05ad02, 0x9c05ae02, 0x9c05af02, 0x9c05b002, 0x9c05b102, 0x9c05b202, 0x9c05b302, + 0x9c05b402, 0x9c05b502, 0x9c05b602, 0x9c05b702, 0x9c05b802, 0x9c05b902, 0x9c05ba02, 0x9c05bb02, + 0x9c05bc02, 0x9c05bd02, 0x9c05be02, 0x9c05bf02, 0x9c05c002, 0x9c05c102, 0x9c05c202, 0x9c05c302, + 0x9c05c402, 0x9c05c502, 0x9c05c602, 0x9c05c702, 0x9c05c802, 0x9c05c902, 0x9c05ca02, 0x9c05cb02, + 0x9c05cc02, 0x9c05cd02, 0x9c05ce02, 0x9c05cf02, 0x9c05d002, 0x9c05d102, 0x9c05d202, 0x9c05d302, + 0x9c05d402, 0x9c05d502, 0x9c05d602, 0x9c05d702, 0x9c05d802, 0x9c05d902, 0x9c05da02, 0x9c05db02, + 0x9c05dc02, 0x9c05dd02, 0x9c05de02, 0x9c05df02, 0x9c05e002, 0x9c05e102, 0x9c05e202, 0x9c05e302, + 0x9c05e402, 0x9c05e502, 0x9c05e602, 0x9c05e702, 0x9c05e802, 0x9c05e902, 0x9c05ea02, 0x9c05eb02, + 0x9c05ec02, 0x9c05ed02, 0x9c05ee02, 0x9c05ef02, 0x9c05f002, 0x9c05f102, 0x9c05f202, 0x9c05f302, + 0x9c05f402, 0x9c05f502, 0x9c05f602, 0x9c05f702, 0x9c05f802, 0x9c05f902, 0x9c05fa02, 0x9c05fb02, + 0x9c05fc02, 0x9c05fd02, 0x9c05fe02, 0x9c05ff02, 0x9d050202, 0x9d050302, 0x9d050402, 0x9d050502, + 0x9d050602, 0x9d050702, 0x9d050802, 0x9d050902, 0x9d050a02, 0x9d050b02, 0x9d050c02, 0x9d050d02, + 0x9d050e02, 0x9d050f02, 0x9d051002, 0x9d051102, 0x9d051202, 0x9d051302, 0x9d051402, 0x9d051502, + 0x9d051602, 0x9d051702, 0x9d051802, 0x9d051902, 0x9d051a02, 0x9d051b02, 0x9d051c02, 0x9d051d02, + 0x9d051e02, 0x9d051f02, 0x9d052002, 0x9d052102, 0x9d052202, 0x9d052302, 0x9d052402, 0x9d052502, + 0x9d052602, 0x9d052702, 0x9d052802, 0x9d052902, 0x9d052a02, 0x9d052b02, 0x9d052c02, 0x9d052d02, + 0x9d052e02, 0x9d052f02, 0x9d053002, 0x9d053102, 0x9d053202, 0x9d053302, 0x9d053402, 0x9d053502, + 0x9d053602, 0x9d053702, 0x9d053802, 0x9d053902, 0x9d053a02, 0x9d053b02, 0x9d053c02, 0x9d053d02, + 0x9d053e02, 0x9d053f02, 0x9d054002, 0x9d054102, 0x9d054202, 0x9d054302, 0x9d054402, 0x9d054502, + 0x9d054602, 0x9d054702, 0x9d054802, 0x9d054902, 0x9d054a02, 0x9d054b02, 0x9d054c02, 0x9d054d02, + 0x9d054e02, 0x9d054f02, 0x9d055002, 0x9d055102, 0x9d055202, 0x9d055302, 0x9d055402, 0x9d055502, + 0x9d055602, 0x9d055702, 0x9d055802, 0x9d055902, 0x9d055a02, 0x9d055b02, 0x9d055c02, 0x9d055d02, + 0x9d055e02, 0x9d055f02, 0x9d056002, 0x9d056102, 0x9d056202, 0x9d056302, 0x9d056402, 0x9d056502, + 0x9d056602, 0x9d056702, 0x9d056802, 0x9d056902, 0x9d056a02, 0x9d056b02, 0x9d056c02, 0x9d056d02, + 0x9d056e02, 0x9d056f02, 0x9d057002, 0x9d057102, 0x9d057202, 0x9d057302, 0x9d057402, 0x9d057502, + 0x9d057602, 0x9d057702, 0x9d057802, 0x9d057902, 0x9d057a02, 0x9d057b02, 0x9d057c02, 0x9d057d02, + 0x9d057e02, 0x9d057f02, 0x9d058002, 0x9d058102, 0x9d058202, 0x9d058302, 0x9d058402, 0x9d058502, + 0x9d058602, 0x9d058702, 0x9d058802, 0x9d058902, 0x9d058a02, 0x9d058b02, 0x9d058c02, 0x9d058d02, + 0x9d058e02, 0x9d058f02, 0x9d059002, 0x9d059102, 0x9d059202, 0x9d059302, 0x9d059402, 0x9d059502, + 0x9d059602, 0x9d059702, 0x9d059802, 0x9d059902, 0x9d059a02, 0x9d059b02, 0x9d059c02, 0x9d059d02, + 0x9d059e02, 0x9d059f02, 0x9d05a002, 0x9d05a102, 0x9d05a202, 0x9d05a302, 0x9d05a402, 0x9d05a502, + 0x9d05a602, 0x9d05a702, 0x9d05a802, 0x9d05a902, 0x9d05aa02, 0x9d05ab02, 0x9d05ac02, 0x9d05ad02, + 0x9d05ae02, 0x9d05af02, 0x9d05b002, 0x9d05b102, 0x9d05b202, 0x9d05b302, 0x9d05b402, 0x9d05b502, + 0x9d05b602, 0x9d05b702, 0x9d05b802, 0x9d05b902, 0x9d05ba02, 0x9d05bb02, 0x9d05bc02, 0x9d05bd02, + 0x9d05be02, 0x9d05bf02, 0x9d05c002, 0x9d05c102, 0x9d05c202, 0x9d05c302, 0x9d05c402, 0x9d05c502, + 0x9d05c602, 0x9d05c702, 0x9d05c802, 0x9d05c902, 0x9d05ca02, 0x9d05cb02, 0x9d05cc02, 0x9d05cd02, + 0x9d05ce02, 0x9d05cf02, 0x9d05d002, 0x9d05d102, 0x9d05d202, 0x9d05d302, 0x9d05d402, 0x9d05d502, + 0x9d05d602, 0x9d05d702, 0x9d05d802, 0x9d05d902, 0x9d05da02, 0x9d05db02, 0x9d05dc02, 0x9d05dd02, + 0x9d05de02, 0x9d05df02, 0x9d05e002, 0x9d05e102, 0x9d05e202, 0x9d05e302, 0x9d05e402, 0x9d05e502, + 0x9d05e602, 0x9d05e702, 0x9d05e802, 0x9d05e902, 0x9d05ea02, 0x9d05eb02, 0x9d05ec02, 0x9d05ed02, + 0x9d05ee02, 0x9d05ef02, 0x9d05f002, 0x9d05f102, 0x9d05f202, 0x9d05f302, 0x9d05f402, 0x9d05f502, + 0x9d05f602, 0x9d05f702, 0x9d05f802, 0x9d05f902, 0x9d05fa02, 0x9d05fb02, 0x9d05fc02, 0x9d05fd02, + 0x9d05fe02, 0x9d05ff02, 0x9e050202, 0x9e050302, 0x9e050402, 0x9e050502, 0x9e050602, 0x9e050702, + 0x9e050802, 0x9e050902, 0x9e050a02, 0x9e050b02, 0x9e050c02, 0x9e050d02, 0x9e050e02, 0x9e050f02, + 0x9e051002, 0x9e051102, 0x9e051202, 0x9e051302, 0x9e051402, 0x9e051502, 0x9e051602, 0x9e051702, + 0x9e051802, 0x9e051902, 0x9e051a02, 0x9e051b02, 0x9e051c02, 0x9e051d02, 0x9e051e02, 0x9e051f02, + 0x9e052002, 0x9e052102, 0x9e052202, 0x9e052302, 0x9e052402, 0x9e052502, 0x9e052602, 0x9e052702, + 0x9e052802, 0x9e052902, 0x9e052a02, 0x9e052b02, 0x9e052c02, 0x9e052d02, 0x9e052e02, 0x9e052f02, + 0x9e053002, 0x9e053102, 0x9e053202, 0x9e053302, 0x9e053402, 0x9e053502, 0x9e053602, 0x9e053702, + 0x9e053802, 0x9e053902, 0x9e053a02, 0x9e053b02, 0x9e053c02, 0x9e053d02, 0x9e053e02, 0x9e053f02, + 0x9e054002, 0x9e054102, 0x9e054202, 0x9e054302, 0x9e054402, 0x9e054502, 0x9e054602, 0x9e054702, + 0x9e054802, 0x9e054902, 0x9e054a02, 0x9e054b02, 0x9e054c02, 0x9e054d02, 0x9e054e02, 0x9e054f02, + 0x9e055002, 0x9e055102, 0x9e055202, 0x9e055302, 0x9e055402, 0x9e055502, 0x9e055602, 0x9e055702, + 0x9e055802, 0x9e055902, 0x9e055a02, 0x9e055b02, 0x9e055c02, 0x9e055d02, 0x9e055e02, 0x9e055f02, + 0x9e056002, 0x9e056102, 0x9e056202, 0x9e056302, 0x9e056402, 0x9e056502, 0x9e056602, 0x9e056702, + 0x9e056802, 0x9e056902, 0x9e056a02, 0x9e056b02, 0x9e056c02, 0x9e056d02, 0x9e056e02, 0x9e056f02, + 0x9e057002, 0x9e057102, 0x9e057202, 0x9e057302, 0x9e057402, 0x9e057502, 0x9e057602, 0x9e057702, + 0x9e057802, 0x9e057902, 0x9e057a02, 0x9e057b02, 0x9e057c02, 0x9e057d02, 0x9e057e02, 0x9e057f02, + 0x9e058002, 0x9e058102, 0x9e058202, 0x9e058302, 0x9e058402, 0x9e058502, 0x9e058602, 0x9e058702, + 0x9e058802, 0x9e058902, 0x9e058a02, 0x9e058b02, 0x9e058c02, 0x9e058d02, 0x9e058e02, 0x9e058f02, + 0x9e059002, 0x9e059102, 0x9e059202, 0x9e059302, 0x9e059402, 0x9e059502, 0x9e059602, 0x9e059702, + 0x9e059802, 0x9e059902, 0x9e059a02, 0x9e059b02, 0x9e059c02, 0x9e059d02, 0x9e059e02, 0x9e059f02, + 0x9e05a002, 0x9e05a102, 0x9e05a202, 0x9e05a302, 0x9e05a402, 0x9e05a502, 0x9e05a602, 0x9e05a702, + 0x9e05a802, 0x9e05a902, 0x9e05aa02, 0x9e05ab02, 0x9e05ac02, 0x9e05ad02, 0x9e05ae02, 0x9e05af02, + 0x9e05b002, 0x9e05b102, 0x9e05b202, 0x9e05b302, 0x9e05b402, 0x9e05b502, 0x9e05b602, 0x9e05b702, + 0x9e05b802, 0x9e05b902, 0x9e05ba02, 0x9e05bb02, 0x9e05bc02, 0x9e05bd02, 0x9e05be02, 0x9e05bf02, + 0x9e05c002, 0x9e05c102, 0x9e05c202, 0x9e05c302, 0x9e05c402, 0x9e05c502, 0x9e05c602, 0x9e05c702, + 0x9e05c802, 0x9e05c902, 0x9e05ca02, 0x9e05cb02, 0x9e05cc02, 0x9e05cd02, 0x9e05ce02, 0x9e05cf02, + 0x9e05d002, 0x9e05d102, 0x9e05d202, 0x9e05d302, 0x9e05d402, 0x9e05d502, 0x9e05d602, 0x9e05d702, + 0x9e05d802, 0x9e05d902, 0x9e05da02, 0x9e05db02, 0x9e05dc02, 0x9e05dd02, 0x9e05de02, 0x9e05df02, + 0x9e05e002, 0x9e05e102, 0x9e05e202, 0x9e05e302, 0x9e05e402, 0x9e05e502, 0x9e05e602, 0x9e05e702, + 0x9e05e802, 0x9e05e902, 0x9e05ea02, 0x9e05eb02, 0x9e05ec02, 0x9e05ed02, 0x9e05ee02, 0x9e05ef02, + 0x9e05f002, 0x9e05f102, 0x9e05f202, 0x9e05f302, 0x9e05f402, 0x9e05f502, 0x9e05f602, 0x9e05f702, + 0x9e05f802, 0x9e05f902, 0x9e05fa02, 0x9e05fb02, 0x9e05fc02, 0x9e05fd02, 0x9e05fe02, 0x9e05ff02, + 0x9f050202, 0x9f050302, 0x9f050402, 0x9f050502, 0x9f050602, 0x9f050702, 0x9f050802, 0x9f050902, + 0x9f050a02, 0x9f050b02, 0x9f050c02, 0x9f050d02, 0x9f050e02, 0x9f050f02, 0x9f051002, 0x9f051102, + 0x9f051202, 0x9f051302, 0x9f051402, 0x9f051502, 0x9f051602, 0x9f051702, 0x9f051802, 0x9f051902, + 0x9f051a02, 0x9f051b02, 0x9f051c02, 0x9f051d02, 0x9f051e02, 0x9f051f02, 0x9f052002, 0x9f052102, + 0x9f052202, 0x9f052302, 0x9f052402, 0x9f052502, 0x9f052602, 0x9f052702, 0x9f052802, 0x9f052902, + 0x9f052a02, 0x9f052b02, 0x9f052c02, 0x9f052d02, 0x9f052e02, 0x9f052f02, 0x9f053002, 0x9f053102, + 0x9f053202, 0x9f053302, 0x9f053402, 0x9f053502, 0x9f053602, 0x9f053702, 0x9f053802, 0x9f053902, + 0x9f053a02, 0x9f053b02, 0x9f053c02, 0x9f053d02, 0x9f053e02, 0x9f053f02, 0x9f054002, 0x9f054102, + 0x9f054202, 0x9f054302, 0x9f054402, 0x9f054502, 0x9f054602, 0x9f054702, 0x9f054802, 0x9f054902, + 0x9f054a02, 0x9f054b02, 0x9f054c02, 0x9f054d02, 0x9f054e02, 0x9f054f02, 0x9f055002, 0x9f055102, + 0x9f055202, 0x9f055302, 0x9f055402, 0x9f055502, 0x9f055602, 0x9f055702, 0x9f055802, 0x9f055902, + 0x9f055a02, 0x9f055b02, 0x9f055c02, 0x9f055d02, 0x9f055e02, 0x9f055f02, 0x9f056002, 0x9f056102, + 0x9f056202, 0x9f056302, 0x9f056402, 0x9f056502, 0x9f056602, 0x9f056702, 0x9f056802, 0x9f056902, + 0x9f056a02, 0x9f056b02, 0x9f056c02, 0x9f056d02, 0x9f056e02, 0x9f056f02, 0x9f057002, 0x9f057102, + 0x9f057202, 0x9f057302, 0x9f057402, 0x9f057502, 0x9f057602, 0x9f057702, 0x9f057802, 0x9f057902, + 0x9f057a02, 0x9f057b02, 0x9f057c02, 0x9f057d02, 0x9f057e02, 0x9f057f02, 0x9f058002, 0x9f058102, + 0x9f058202, 0x9f058302, 0x9f058402, 0x9f058502, 0x9f058602, 0x9f058702, 0x9f058802, 0x9f058902, + 0x9f058a02, 0x9f058b02, 0x9f058c02, 0x9f058d02, 0x9f058e02, 0x9f058f02, 0x9f059002, 0x9f059102, + 0x9f059202, 0x9f059302, 0x9f059402, 0x9f059502, 0x9f059602, 0x9f059702, 0x9f059802, 0x9f059902, + 0x9f059a02, 0x9f059b02, 0x9f059c02, 0x9f059d02, 0x9f059e02, 0x9f059f02, 0x9f05a002, 0x9f05a102, + 0x9f05a202, 0x9f05a302, 0x9f05a402, 0x9f05a502, 0x9f05a602, 0x9f05a702, 0x9f05a802, 0x9f05a902, + 0x9f05aa02, 0x9f05ab02, 0x9f05ac02, 0x9f05ad02, 0x9f05ae02, 0x9f05af02, 0x9f05b002, 0x9f05b102, + 0x9f05b202, 0x9f05b302, 0x9f05b402, 0x9f05b502, 0x9f05b602, 0x9f05b702, 0x9f05b802, 0x9f05b902, + 0x9f05ba02, 0x9f05bb02, 0x9f05bc02, 0x9f05bd02, 0x9f05be02, 0x9f05bf02, 0x9f05c002, 0x9f05c102, + 0x9f05c202, 0x9f05c302, 0x9f05c402, 0x9f05c502, 0x9f05c602, 0x9f05c702, 0x9f05c802, 0x9f05c902, + 0x9f05ca02, 0x9f05cb02, 0x9f05cc02, 0x9f05cd02, 0x9f05ce02, 0x9f05cf02, 0x9f05d002, 0x9f05d102, + 0x9f05d202, 0x9f05d302, 0x9f05d402, 0x9f05d502, 0x9f05d602, 0x9f05d702, 0x9f05d802, 0x9f05d902, + 0x9f05da02, 0x9f05db02, 0x9f05dc02, 0x9f05dd02, 0x9f05de02, 0x9f05df02, 0x9f05e002, 0x9f05e102, + 0x9f05e202, 0x9f05e302, 0x9f05e402, 0x9f05e502, 0x9f05e602, 0x9f05e702, 0x9f05e802, 0x9f05e902, + 0x9f05ea02, 0x9f05eb02, 0x9f05ec02, 0x9f05ed02, 0x9f05ee02, 0x9f05ef02, 0x9f05f002, 0x9f05f102, + 0x9f05f202, 0x9f05f302, 0x9f05f402, 0x9f05f502, 0x9f05f602, 0x9f05f702, 0x9f05f802, 0x9f05f902, + 0x9f05fa02, 0x9f05fb02, 0x9f05fc02, 0x9f05fd02, 0x9f05fe02, 0x9f05ff02, 0xa0050202, 0xa0050302, + 0xa0050402, 0xa0050502, 0xa0050602, 0xa0050702, 0xa0050802, 0xa0050902, 0xa0050a02, 0xa0050b02, + 0xa0050c02, 0xa0050d02, 0xa0050e02, 0xa0050f02, 0xa0051002, 0xa0051102, 0xa0051202, 0xa0051302, + 0xa0051402, 0xa0051502, 0xa0051602, 0xa0051702, 0xa0051802, 0xa0051902, 0xa0051a02, 0xa0051b02, + 0xa0051c02, 0xa0051d02, 0xa0051e02, 0xa0051f02, 0xa0052002, 0xa0052102, 0xa0052202, 0xa0052302, + 0xa0052402, 0xa0052502, 0xa0052602, 0xa0052702, 0xa0052802, 0xa0052902, 0xa0052a02, 0xa0052b02, + 0xa0052c02, 0xa0052d02, 0xa0052e02, 0xa0052f02, 0xa0053002, 0xa0053102, 0xa0053202, 0xa0053302, + 0xa0053402, 0xa0053502, 0xa0053602, 0xa0053702, 0xa0053802, 0xa0053902, 0xa0053a02, 0xa0053b02, + 0xa0053c02, 0xa0053d02, 0xa0053e02, 0xa0053f02, 0xa0054002, 0xa0054102, 0xa0054202, 0xa0054302, + 0xa0054402, 0xa0054502, 0xa0054602, 0xa0054702, 0xa0054802, 0xa0054902, 0xa0054a02, 0xa0054b02, + 0xa0054c02, 0xa0054d02, 0xa0054e02, 0xa0054f02, 0xa0055002, 0xa0055102, 0xa0055202, 0xa0055302, + 0xa0055402, 0xa0055502, 0xa0055602, 0xa0055702, 0xa0055802, 0xa0055902, 0xa0055a02, 0xa0055b02, + 0xa0055c02, 0xa0055d02, 0xa0055e02, 0xa0055f02, 0xa0056002, 0xa0056102, 0xa0056202, 0xa0056302, + 0xa0056402, 0xa0056502, 0xa0056602, 0xa0056702, 0xa0056802, 0xa0056902, 0xa0056a02, 0xa0056b02, + 0xa0056c02, 0xa0056d02, 0xa0056e02, 0xa0056f02, 0xa0057002, 0xa0057102, 0xa0057202, 0xa0057302, + 0xa0057402, 0xa0057502, 0xa0057602, 0xa0057702, 0xa0057802, 0xa0057902, 0xa0057a02, 0xa0057b02, + 0xa0057c02, 0xa0057d02, 0xa0057e02, 0xa0057f02, 0xa0058002, 0xa0058102, 0xa0058202, 0xa0058302, + 0xa0058402, 0xa0058502, 0xa0058602, 0xa0058702, 0xa0058802, 0xa0058902, 0xa0058a02, 0xa0058b02, + 0xa0058c02, 0xa0058d02, 0xa0058e02, 0xa0058f02, 0xa0059002, 0xa0059102, 0xa0059202, 0xa0059302, + 0xa0059402, 0xa0059502, 0xa0059602, 0xa0059702, 0xa0059802, 0xa0059902, 0xa0059a02, 0xa0059b02, + 0xa0059c02, 0xa0059d02, 0xa0059e02, 0xa0059f02, 0xa005a002, 0xa005a102, 0xa005a202, 0xa005a302, + 0xa005a402, 0xa005a502, 0xa005a602, 0xa005a702, 0xa005a802, 0xa005a902, 0xa005aa02, 0xa005ab02, + 0xa005ac02, 0xa005ad02, 0xa005ae02, 0xa005af02, 0xa005b002, 0xa005b102, 0xa005b202, 0xa005b302, + 0xa005b402, 0xa005b502, 0xa005b602, 0xa005b702, 0xa005b802, 0xa005b902, 0xa005ba02, 0xa005bb02, + 0xa005bc02, 0xa005bd02, 0xa005be02, 0xa005bf02, 0xa005c002, 0xa005c102, 0xa005c202, 0xa005c302, + 0xa005c402, 0xa005c502, 0xa005c602, 0xa005c702, 0xa005c802, 0xa005c902, 0xa005ca02, 0xa005cb02, + 0xa005cc02, 0xa005cd02, 0xa005ce02, 0xa005cf02, 0xa005d002, 0xa005d102, 0xa005d202, 0xa005d302, + 0xa005d402, 0xa005d502, 0xa005d602, 0xa005d702, 0xa005d802, 0xa005d902, 0xa005da02, 0xa005db02, + 0xa005dc02, 0xa005dd02, 0xa005de02, 0xa005df02, 0xa005e002, 0xa005e102, 0xa005e202, 0xa005e302, + 0xa005e402, 0xa005e502, 0xa005e602, 0xa005e702, 0xa005e802, 0xa005e902, 0xa005ea02, 0xa005eb02, + 0xa005ec02, 0xa005ed02, 0xa005ee02, 0xa005ef02, 0xa005f002, 0xa005f102, 0xa005f202, 0xa005f302, + 0xa005f402, 0xa005f502, 0xa005f602, 0xa005f702, 0xa005f802, 0xa005f902, 0xa005fa02, 0xa005fb02, + 0xa005fc02, 0xa005fd02, 0xa005fe02, 0xa005ff02, 0xa1050202, 0xa1050302, 0xa1050402, 0xa1050502, + 0xa1050602, 0xa1050702, 0xa1050802, 0xa1050902, 0xa1050a02, 0xa1050b02, 0xa1050c02, 0xa1050d02, + 0xa1050e02, 0xa1050f02, 0xa1051002, 0xa1051102, 0xa1051202, 0xa1051302, 0xa1051402, 0xa1051502, + 0xa1051602, 0xa1051702, 0xa1051802, 0xa1051902, 0xa1051a02, 0xa1051b02, 0xa1051c02, 0xa1051d02, + 0xa1051e02, 0xa1051f02, 0xa1052002, 0xa1052102, 0xa1052202, 0xa1052302, 0xa1052402, 0xa1052502, + 0xa1052602, 0xa1052702, 0xa1052802, 0xa1052902, 0xa1052a02, 0xa1052b02, 0xa1052c02, 0xa1052d02, + 0xa1052e02, 0xa1052f02, 0xa1053002, 0xa1053102, 0xa1053202, 0xa1053302, 0xa1053402, 0xa1053502, + 0xa1053602, 0xa1053702, 0xa1053802, 0xa1053902, 0xa1053a02, 0xa1053b02, 0xa1053c02, 0xa1053d02, + 0xa1053e02, 0xa1053f02, 0xa1054002, 0xa1054102, 0xa1054202, 0xa1054302, 0xa1054402, 0xa1054502, + 0xa1054602, 0xa1054702, 0xa1054802, 0xa1054902, 0xa1054a02, 0xa1054b02, 0xa1054c02, 0xa1054d02, + 0xa1054e02, 0xa1054f02, 0xa1055002, 0xa1055102, 0xa1055202, 0xa1055302, 0xa1055402, 0xa1055502, + 0xa1055602, 0xa1055702, 0xa1055802, 0xa1055902, 0xa1055a02, 0xa1055b02, 0xa1055c02, 0xa1055d02, + 0xa1055e02, 0xa1055f02, 0xa1056002, 0xa1056102, 0xa1056202, 0xa1056302, 0xa1056402, 0xa1056502, + 0xa1056602, 0xa1056702, 0xa1056802, 0xa1056902, 0xa1056a02, 0xa1056b02, 0xa1056c02, 0xa1056d02, + 0xa1056e02, 0xa1056f02, 0xa1057002, 0xa1057102, 0xa1057202, 0xa1057302, 0xa1057402, 0xa1057502, + 0xa1057602, 0xa1057702, 0xa1057802, 0xa1057902, 0xa1057a02, 0xa1057b02, 0xa1057c02, 0xa1057d02, + 0xa1057e02, 0xa1057f02, 0xa1058002, 0xa1058102, 0xa1058202, 0xa1058302, 0xa1058402, 0xa1058502, + 0xa1058602, 0xa1058702, 0xa1058802, 0xa1058902, 0xa1058a02, 0xa1058b02, 0xa1058c02, 0xa1058d02, + 0xa1058e02, 0xa1058f02, 0xa1059002, 0xa1059102, 0xa1059202, 0xa1059302, 0xa1059402, 0xa1059502, + 0xa1059602, 0xa1059702, 0xa1059802, 0xa1059902, 0xa1059a02, 0xa1059b02, 0xa1059c02, 0xa1059d02, + 0xa1059e02, 0xa1059f02, 0xa105a002, 0xa105a102, 0xa105a202, 0xa105a302, 0xa105a402, 0xa105a502, + 0xa105a602, 0xa105a702, 0xa105a802, 0xa105a902, 0xa105aa02, 0xa105ab02, 0xa105ac02, 0xa105ad02, + 0xa105ae02, 0xa105af02, 0xa105b002, 0xa105b102, 0xa105b202, 0xa105b302, 0xa105b402, 0xa105b502, + 0xa105b602, 0xa105b702, 0xa105b802, 0xa105b902, 0xa105ba02, 0xa105bb02, 0xa105bc02, 0xa105bd02, + 0xa105be02, 0xa105bf02, 0xa105c002, 0xa105c102, 0xa105c202, 0xa105c302, 0xa105c402, 0xa105c502, + 0xa105c602, 0xa105c702, 0xa105c802, 0xa105c902, 0xa105ca02, 0xa105cb02, 0xa105cc02, 0xa105cd02, + 0xa105ce02, 0xa105cf02, 0xa105d002, 0xa105d102, 0xa105d202, 0xa105d302, 0xa105d402, 0xa105d502, + 0xa105d602, 0xa105d702, 0xa105d802, 0xa105d902, 0xa105da02, 0xa105db02, 0xa105dc02, 0xa105dd02, + 0xa105de02, 0xa105df02, 0xa105e002, 0xa105e102, 0xa105e202, 0xa105e302, 0xa105e402, 0xa105e502, + 0xa105e602, 0xa105e702, 0xa105e802, 0xa105e902, 0xa105ea02, 0xa105eb02, 0xa105ec02, 0xa105ed02, + 0xa105ee02, 0xa105ef02, 0xa105f002, 0xa105f102, 0xa105f202, 0xa105f302, 0xa105f402, 0xa105f502, + 0xa105f602, 0xa105f702, 0xa105f802, 0xa105f902, 0xa105fa02, 0xa105fb02, 0xa105fc02, 0xa105fd02, + 0xa105fe02, 0xa105ff02, 0xa2050202, 0xa2050302, 0xa2050402, 0xa2050502, 0xa2050602, 0xa2050702, + 0xa2050802, 0xa2050902, 0xa2050a02, 0xa2050b02, 0xa2050c02, 0xa2050d02, 0xa2050e02, 0xa2050f02, + 0xa2051002, 0xa2051102, 0xa2051202, 0xa2051302, 0xa2051402, 0xa2051502, 0xa2051602, 0xa2051702, + 0xa2051802, 0xa2051902, 0xa2051a02, 0xa2051b02, 0xa2051c02, 0xa2051d02, 0xa2051e02, 0xa2051f02, + 0xa2052002, 0xa2052102, 0xa2052202, 0xa2052302, 0xa2052402, 0xa2052502, 0xa2052602, 0xa2052702, + 0xa2052802, 0xa2052902, 0xa2052a02, 0xa2052b02, 0xa2052c02, 0xa2052d02, 0xa2052e02, 0xa2052f02, + 0xa2053002, 0xa2053102, 0xa2053202, 0xa2053302, 0xa2053402, 0xa2053502, 0xa2053602, 0xa2053702, + 0xa2053802, 0xa2053902, 0xa2053a02, 0xa2053b02, 0xa2053c02, 0xa2053d02, 0xa2053e02, 0xa2053f02, + 0xa2054002, 0xa2054102, 0xa2054202, 0xa2054302, 0xa2054402, 0xa2054502, 0xa2054602, 0xa2054702, + 0xa2054802, 0xa2054902, 0xa2054a02, 0xa2054b02, 0xa2054c02, 0xa2054d02, 0xa2054e02, 0xa2054f02, + 0xa2055002, 0xa2055102, 0xa2055202, 0xa2055302, 0xa2055402, 0xa2055502, 0xa2055602, 0xa2055702, + 0xa2055802, 0xa2055902, 0xa2055a02, 0xa2055b02, 0xa2055c02, 0xa2055d02, 0xa2055e02, 0xa2055f02, + 0xa2056002, 0xa2056102, 0xa2056202, 0xa2056302, 0xa2056402, 0xa2056502, 0xa2056602, 0xa2056702, + 0xa2056802, 0xa2056902, 0xa2056a02, 0xa2056b02, 0xa2056c02, 0xa2056d02, 0xa2056e02, 0xa2056f02, + 0xa2057002, 0xa2057102, 0xa2057202, 0xa2057302, 0xa2057402, 0xa2057502, 0xa2057602, 0xa2057702, + 0xa2057802, 0xa2057902, 0xa2057a02, 0xa2057b02, 0xa2057c02, 0xa2057d02, 0xa2057e02, 0xa2057f02, + 0xa2058002, 0xa2058102, 0xa2058202, 0xa2058302, 0xa2058402, 0xa2058502, 0xa2058602, 0xa2058702, + 0xa2058802, 0xa2058902, 0xa2058a02, 0xa2058b02, 0xa2058c02, 0xa2058d02, 0xa2058e02, 0xa2058f02, + 0xa2059002, 0xa2059102, 0xa2059202, 0xa2059302, 0xa2059402, 0xa2059502, 0xa2059602, 0xa2059702, + 0xa2059802, 0xa2059902, 0xa2059a02, 0xa2059b02, 0xa2059c02, 0xa2059d02, 0xa2059e02, 0xa2059f02, + 0xa205a002, 0xa205a102, 0xa205a202, 0xa205a302, 0xa205a402, 0xa205a502, 0xa205a602, 0xa205a702, + 0xa205a802, 0xa205a902, 0xa205aa02, 0xa205ab02, 0xa205ac02, 0xa205ad02, 0xa205ae02, 0xa205af02, + 0xa205b002, 0xa205b102, 0xa205b202, 0xa205b302, 0xa205b402, 0xa205b502, 0xa205b602, 0xa205b702, + 0xa205b802, 0xa205b902, 0xa205ba02, 0xa205bb02, 0xa205bc02, 0xa205bd02, 0xa205be02, 0xa205bf02, + 0xa205c002, 0xa205c102, 0xa205c202, 0xa205c302, 0xa205c402, 0xa205c502, 0xa205c602, 0xa205c702, + 0xa205c802, 0xa205c902, 0xa205ca02, 0xa205cb02, 0xa205cc02, 0xa205cd02, 0xa205ce02, 0xa205cf02, + 0xa205d002, 0xa205d102, 0xa205d202, 0xa205d302, 0xa205d402, 0xa205d502, 0xa205d602, 0xa205d702, + 0xa205d802, 0xa205d902, 0xa205da02, 0xa205db02, 0xa205dc02, 0xa205dd02, 0xa205de02, 0xa205df02, + 0xa205e002, 0xa205e102, 0xa205e202, 0xa205e302, 0xa205e402, 0xa205e502, 0xa205e602, 0xa205e702, + 0xa205e802, 0xa205e902, 0xa205ea02, 0xa205eb02, 0xa205ec02, 0xa205ed02, 0xa205ee02, 0xa205ef02, + 0xa205f002, 0xa205f102, 0xa205f202, 0xa205f302, 0xa205f402, 0xa205f502, 0xa205f602, 0xa205f702, + 0xa205f802, 0xa205f902, 0xa205fa02, 0xa205fb02, 0xa205fc02, 0xa205fd02, 0xa205fe02, 0xa205ff02, + 0xa3050202, 0xa3050302, 0xa3050402, 0xa3050502, 0xa3050602, 0xa3050702, 0xa3050802, 0xa3050902, + 0xa3050a02, 0xa3050b02, 0xa3050c02, 0xa3050d02, 0xa3050e02, 0xa3050f02, 0xa3051002, 0xa3051102, + 0xa3051202, 0xa3051302, 0xa3051402, 0xa3051502, 0xa3051602, 0xa3051702, 0xa3051802, 0xa3051902, + 0xa3051a02, 0xa3051b02, 0xa3051c02, 0xa3051d02, 0xa3051e02, 0xa3051f02, 0xa3052002, 0xa3052102, + 0xa3052202, 0xa3052302, 0xa3052402, 0xa3052502, 0xa3052602, 0xa3052702, 0xa3052802, 0xa3052902, + 0xa3052a02, 0xa3052b02, 0xa3052c02, 0xa3052d02, 0xa3052e02, 0xa3052f02, 0xa3053002, 0xa3053102, + 0xa3053202, 0xa3053302, 0xa3053402, 0xa3053502, 0xa3053602, 0xa3053702, 0xa3053802, 0xa3053902, + 0xa3053a02, 0xa3053b02, 0xa3053c02, 0xa3053d02, 0xa3053e02, 0xa3053f02, 0xa3054002, 0xa3054102, + 0xa3054202, 0xa3054302, 0xa3054402, 0xa3054502, 0xa3054602, 0xa3054702, 0xa3054802, 0xa3054902, + 0xa3054a02, 0xa3054b02, 0xa3054c02, 0xa3054d02, 0xa3054e02, 0xa3054f02, 0xa3055002, 0xa3055102, + 0xa3055202, 0xa3055302, 0xa3055402, 0xa3055502, 0xa3055602, 0xa3055702, 0xa3055802, 0xa3055902, + 0xa3055a02, 0xa3055b02, 0xa3055c02, 0xa3055d02, 0xa3055e02, 0xa3055f02, 0xa3056002, 0xa3056102, + 0xa3056202, 0xa3056302, 0xa3056402, 0xa3056502, 0xa3056602, 0xa3056702, 0xa3056802, 0xa3056902, + 0xa3056a02, 0xa3056b02, 0xa3056c02, 0xa3056d02, 0xa3056e02, 0xa3056f02, 0xa3057002, 0xa3057102, + 0xa3057202, 0xa3057302, 0xa3057402, 0xa3057502, 0xa3057602, 0xa3057702, 0xa3057802, 0xa3057902, + 0xa3057a02, 0xa3057b02, 0xa3057c02, 0xa3057d02, 0xa3057e02, 0xa3057f02, 0xa3058002, 0xa3058102, + 0xa3058202, 0xa3058302, 0xa3058402, 0xa3058502, 0xa3058602, 0xa3058702, 0xa3058802, 0xa3058902, + 0xa3058a02, 0xa3058b02, 0xa3058c02, 0xa3058d02, 0xa3058e02, 0xa3058f02, 0xa3059002, 0xa3059102, + 0xa3059202, 0xa3059302, 0xa3059402, 0xa3059502, 0xa3059602, 0xa3059702, 0xa3059802, 0xa3059902, + 0xa3059a02, 0xa3059b02, 0xa3059c02, 0xa3059d02, 0xa3059e02, 0xa3059f02, 0xa305a002, 0xa305a102, + 0xa305a202, 0xa305a302, 0xa305a402, 0xa305a502, 0xa305a602, 0xa305a702, 0xa305a802, 0xa305a902, + 0xa305aa02, 0xa305ab02, 0xa305ac02, 0xa305ad02, 0xa305ae02, 0xa305af02, 0xa305b002, 0xa305b102, + 0xa305b202, 0xa305b302, 0xa305b402, 0xa305b502, 0xa305b602, 0xa305b702, 0xa305b802, 0xa305b902, + 0xa305ba02, 0xa305bb02, 0xa305bc02, 0xa305bd02, 0xa305be02, 0xa305bf02, 0xa305c002, 0xa305c102, + 0xa305c202, 0xa305c302, 0xa305c402, 0xa305c502, 0xa305c602, 0xa305c702, 0xa305c802, 0xa305c902, + 0xa305ca02, 0xa305cb02, 0xa305cc02, 0xa305cd02, 0xa305ce02, 0xa305cf02, 0xa305d002, 0xa305d102, + 0xa305d202, 0xa305d302, 0xa305d402, 0xa305d502, 0xa305d602, 0xa305d702, 0xa305d802, 0xa305d902, + 0xa305da02, 0xa305db02, 0xa305dc02, 0xa305dd02, 0xa305de02, 0xa305df02, 0xa305e002, 0xa305e102, + 0xa305e202, 0xa305e302, 0xa305e402, 0xa305e502, 0xa305e602, 0xa305e702, 0xa305e802, 0xa305e902, + 0xa305ea02, 0xa305eb02, 0xa305ec02, 0xa305ed02, 0xa305ee02, 0xa305ef02, 0xa305f002, 0xa305f102, + 0xa305f202, 0xa305f302, 0xa305f402, 0xa305f502, 0xa305f602, 0xa305f702, 0xa305f802, 0xa305f902, + 0xa305fa02, 0xa305fb02, 0xa305fc02, 0xa305fd02, 0xa305fe02, 0xa305ff02, 0xa4050202, 0xa4050302, + 0xa4050402, 0xa4050502, 0xa4050602, 0xa4050702, 0xa4050802, 0xa4050902, 0xa4050a02, 0xa4050b02, + 0xa4050c02, 0xa4050d02, 0xa4050e02, 0xa4050f02, 0xa4051002, 0xa4051102, 0xa4051202, 0xa4051302, + 0xa4051402, 0xa4051502, 0xa4051602, 0xa4051702, 0xa4051802, 0xa4051902, 0xa4051a02, 0xa4051b02, + 0xa4051c02, 0xa4051d02, 0xa4051e02, 0xa4051f02, 0xa4052002, 0xa4052102, 0xa4052202, 0xa4052302, + 0xa4052402, 0xa4052502, 0xa4052602, 0xa4052702, 0xa4052802, 0xa4052902, 0xa4052a02, 0xa4052b02, + 0xa4052c02, 0xa4052d02, 0xa4052e02, 0xa4052f02, 0xa4053002, 0xa4053102, 0xa4053202, 0xa4053302, + 0xa4053402, 0xa4053502, 0xa4053602, 0xa4053702, 0xa4053802, 0xa4053902, 0xa4053a02, 0xa4053b02, + 0xa4053c02, 0xa4053d02, 0xa4053e02, 0xa4053f02, 0xa4054002, 0xa4054102, 0xa4054202, 0xa4054302, + 0xa4054402, 0xa4054502, 0xa4054602, 0xa4054702, 0xa4054802, 0xa4054902, 0xa4054a02, 0xa4054b02, + 0xa4054c02, 0xa4054d02, 0xa4054e02, 0xa4054f02, 0xa4055002, 0xa4055102, 0xa4055202, 0xa4055302, + 0xa4055402, 0xa4055502, 0xa4055602, 0xa4055702, 0xa4055802, 0xa4055902, 0xa4055a02, 0xa4055b02, + 0xa4055c02, 0xa4055d02, 0xa4055e02, 0xa4055f02, 0xa4056002, 0xa4056102, 0xa4056202, 0xa4056302, + 0xa4056402, 0xa4056502, 0xa4056602, 0xa4056702, 0xa4056802, 0xa4056902, 0xa4056a02, 0xa4056b02, + 0xa4056c02, 0xa4056d02, 0xa4056e02, 0xa4056f02, 0xa4057002, 0xa4057102, 0xa4057202, 0xa4057302, + 0xa4057402, 0xa4057502, 0xa4057602, 0xa4057702, 0xa4057802, 0xa4057902, 0xa4057a02, 0xa4057b02, + 0xa4057c02, 0xa4057d02, 0xa4057e02, 0xa4057f02, 0xa4058002, 0xa4058102, 0xa4058202, 0xa4058302, + 0xa4058402, 0xa4058502, 0xa4058602, 0xa4058702, 0xa4058802, 0xa4058902, 0xa4058a02, 0xa4058b02, + 0xa4058c02, 0xa4058d02, 0xa4058e02, 0xa4058f02, 0xa4059002, 0xa4059102, 0xa4059202, 0xa4059302, + 0xa4059402, 0xa4059502, 0xa4059602, 0xa4059702, 0xa4059802, 0xa4059902, 0xa4059a02, 0xa4059b02, + 0xa4059c02, 0xa4059d02, 0xa4059e02, 0xa4059f02, 0xa405a002, 0xa405a102, 0xa405a202, 0xa405a302, + 0xa405a402, 0xa405a502, 0xa405a602, 0xa405a702, 0xa405a802, 0xa405a902, 0xa405aa02, 0xa405ab02, + 0xa405ac02, 0xa405ad02, 0xa405ae02, 0xa405af02, 0xa405b002, 0xa405b102, 0xa405b202, 0xa405b302, + 0xa405b402, 0xa405b502, 0xa405b602, 0xa405b702, 0xa405b802, 0xa405b902, 0xa405ba02, 0xa405bb02, + 0xa405bc02, 0xa405bd02, 0xa405be02, 0xa405bf02, 0xa405c002, 0xa405c102, 0xa405c202, 0xa405c302, + 0xa405c402, 0xa405c502, 0xa405c602, 0xa405c702, 0xa405c802, 0xa405c902, 0xa405ca02, 0xa405cb02, + 0xa405cc02, 0xa405cd02, 0xa405ce02, 0xa405cf02, 0xa405d002, 0xa405d102, 0xa405d202, 0xa405d302, + 0xa405d402, 0xa405d502, 0xa405d602, 0xa405d702, 0xa405d802, 0xa405d902, 0xa405da02, 0xa405db02, + 0xa405dc02, 0xa405dd02, 0xa405de02, 0xa405df02, 0xa405e002, 0xa405e102, 0xa405e202, 0xa405e302, + 0xa405e402, 0xa405e502, 0xa405e602, 0xa405e702, 0xa405e802, 0xa405e902, 0xa405ea02, 0xa405eb02, + 0xa405ec02, 0xa405ed02, 0xa405ee02, 0xa405ef02, 0xa405f002, 0xa405f102, 0xa405f202, 0xa405f302, + 0xa405f402, 0xa405f502, 0xa405f602, 0xa405f702, 0xa405f802, 0xa405f902, 0xa405fa02, 0xa405fb02, + 0xa405fc02, 0xa405fd02, 0xa405fe02, 0xa405ff02, 0xa5050202, 0xa5050302, 0xa5050402, 0xa5050502, + 0xa5050602, 0xa5050702, 0xa5050802, 0xa5050902, 0xa5050a02, 0xa5050b02, 0xa5050c02, 0xa5050d02, + 0xa5050e02, 0xa5050f02, 0xa5051002, 0xa5051102, 0xa5051202, 0xa5051302, 0xa5051402, 0xa5051502, + 0xa5051602, 0xa5051702, 0xa5051802, 0xa5051902, 0xa5051a02, 0xa5051b02, 0xa5051c02, 0xa5051d02, + 0xa5051e02, 0xa5051f02, 0xa5052002, 0xa5052102, 0xa5052202, 0xa5052302, 0xa5052402, 0xa5052502, + 0xa5052602, 0xa5052702, 0xa5052802, 0xa5052902, 0xa5052a02, 0xa5052b02, 0xa5052c02, 0xa5052d02, + 0xa5052e02, 0xa5052f02, 0xa5053002, 0xa5053102, 0xa5053202, 0xa5053302, 0xa5053402, 0xa5053502, + 0xa5053602, 0xa5053702, 0xa5053802, 0xa5053902, 0xa5053a02, 0xa5053b02, 0xa5053c02, 0xa5053d02, + 0xa5053e02, 0xa5053f02, 0xa5054002, 0xa5054102, 0xa5054202, 0xa5054302, 0xa5054402, 0xa5054502, + 0xa5054602, 0xa5054702, 0xa5054802, 0xa5054902, 0xa5054a02, 0xa5054b02, 0xa5054c02, 0xa5054d02, + 0xa5054e02, 0xa5054f02, 0xa5055002, 0xa5055102, 0xa5055202, 0xa5055302, 0xa5055402, 0xa5055502, + 0xa5055602, 0xa5055702, 0xa5055802, 0xa5055902, 0xa5055a02, 0xa5055b02, 0xa5055c02, 0xa5055d02, + 0xa5055e02, 0xa5055f02, 0xa5056002, 0xa5056102, 0xa5056202, 0xa5056302, 0xa5056402, 0xa5056502, + 0xa5056602, 0xa5056702, 0xa5056802, 0xa5056902, 0xa5056a02, 0xa5056b02, 0xa5056c02, 0xa5056d02, + 0xa5056e02, 0xa5056f02, 0xa5057002, 0xa5057102, 0xa5057202, 0xa5057302, 0xa5057402, 0xa5057502, + 0xa5057602, 0xa5057702, 0xa5057802, 0xa5057902, 0xa5057a02, 0xa5057b02, 0xa5057c02, 0xa5057d02, + 0xa5057e02, 0xa5057f02, 0xa5058002, 0xa5058102, 0xa5058202, 0xa5058302, 0xa5058402, 0xa5058502, + 0xa5058602, 0xa5058702, 0xa5058802, 0xa5058902, 0xa5058a02, 0xa5058b02, 0xa5058c02, 0xa5058d02, + 0xa5058e02, 0xa5058f02, 0xa5059002, 0xa5059102, 0xa5059202, 0xa5059302, 0xa5059402, 0xa5059502, + 0xa5059602, 0xa5059702, 0xa5059802, 0xa5059902, 0xa5059a02, 0xa5059b02, 0xa5059c02, 0xa5059d02, + 0xa5059e02, 0xa5059f02, 0xa505a002, 0xa505a102, 0xa505a202, 0xa505a302, 0xa505a402, 0xa505a502, + 0xa505a602, 0xa505a702, 0xa505a802, 0xa505a902, 0xa505aa02, 0xa505ab02, 0xa505ac02, 0xa505ad02, + 0xa505ae02, 0xa505af02, 0xa505b002, 0xa505b102, 0xa505b202, 0xa505b302, 0xa505b402, 0xa505b502, + 0xa505b602, 0xa505b702, 0xa505b802, 0xa505b902, 0xa505ba02, 0xa505bb02, 0xa505bc02, 0xa505bd02, + 0xa505be02, 0xa505bf02, 0xa505c002, 0xa505c102, 0xa505c202, 0xa505c302, 0xa505c402, 0xa505c502, + 0xa505c602, 0xa505c702, 0xa505c802, 0xa505c902, 0xa505ca02, 0xa505cb02, 0xa505cc02, 0xa505cd02, + 0xa505ce02, 0xa505cf02, 0xa505d002, 0xa505d102, 0xa505d202, 0xa505d302, 0xa505d402, 0xa505d502, + 0xa505d602, 0xa505d702, 0xa505d802, 0xa505d902, 0xa505da02, 0xa505db02, 0xa505dc02, 0xa505dd02, + 0xa505de02, 0xa505df02, 0xa505e002, 0xa505e102, 0xa505e202, 0xa505e302, 0xa505e402, 0xa505e502, + 0xa505e602, 0xa505e702, 0xa505e802, 0xa505e902, 0xa505ea02, 0xa505eb02, 0xa505ec02, 0xa505ed02, + 0xa505ee02, 0xa505ef02, 0xa505f002, 0xa505f102, 0xa505f202, 0xa505f302, 0xa505f402, 0xa505f502, + 0xa505f602, 0xa505f702, 0xa505f802, 0xa505f902, 0xa505fa02, 0xa505fb02, 0xa505fc02, 0xa505fd02, + 0xa505fe02, 0xa505ff02, 0xa6050202, 0xa6050302, 0xa6050402, 0xa6050502, 0xa6050602, 0xa6050702, + 0xa6050802, 0xa6050902, 0xa6050a02, 0xa6050b02, 0xa6050c02, 0xa6050d02, 0xa6050e02, 0xa6050f02, + 0xa6051002, 0xa6051102, 0xa6051202, 0xa6051302, 0xa6051402, 0xa6051502, 0xa6051602, 0xa6051702, + 0xa6051802, 0xa6051902, 0xa6051a02, 0xa6051b02, 0xa6051c02, 0xa6051d02, 0xa6051e02, 0xa6051f02, + 0xa6052002, 0xa6052102, 0xa6052202, 0xa6052302, 0xa6052402, 0xa6052502, 0xa6052602, 0xa6052702, + 0xa6052802, 0xa6052902, 0xa6052a02, 0xa6052b02, 0xa6052c02, 0xa6052d02, 0xa6052e02, 0xa6052f02, + 0xa6053002, 0xa6053102, 0xa6053202, 0xa6053302, 0xa6053402, 0xa6053502, 0xa6053602, 0xa6053702, + 0xa6053802, 0xa6053902, 0xa6053a02, 0xa6053b02, 0xa6053c02, 0xa6053d02, 0xa6053e02, 0xa6053f02, + 0xa6054002, 0xa6054102, 0xa6054202, 0xa6054302, 0xa6054402, 0xa6054502, 0xa6054602, 0xa6054702, + 0xa6054802, 0xa6054902, 0xa6054a02, 0xa6054b02, 0xa6054c02, 0xa6054d02, 0xa6054e02, 0xa6054f02, + 0xa6055002, 0xa6055102, 0xa6055202, 0xa6055302, 0xa6055402, 0xa6055502, 0xa6055602, 0xa6055702, + 0xa6055802, 0xa6055902, 0xa6055a02, 0xa6055b02, 0xa6055c02, 0xa6055d02, 0xa6055e02, 0xa6055f02, + 0xa6056002, 0xa6056102, 0xa6056202, 0xa6056302, 0xa6056402, 0xa6056502, 0xa6056602, 0xa6056702, + 0xa6056802, 0xa6056902, 0xa6056a02, 0xa6056b02, 0xa6056c02, 0xa6056d02, 0xa6056e02, 0xa6056f02, + 0xa6057002, 0xa6057102, 0xa6057202, 0xa6057302, 0xa6057402, 0xa6057502, 0xa6057602, 0xa6057702, + 0xa6057802, 0xa6057902, 0xa6057a02, 0xa6057b02, 0xa6057c02, 0xa6057d02, 0xa6057e02, 0xa6057f02, + 0xa6058002, 0xa6058102, 0xa6058202, 0xa6058302, 0xa6058402, 0xa6058502, 0xa6058602, 0xa6058702, + 0xa6058802, 0xa6058902, 0xa6058a02, 0xa6058b02, 0xa6058c02, 0xa6058d02, 0xa6058e02, 0xa6058f02, + 0xa6059002, 0xa6059102, 0xa6059202, 0xa6059302, 0xa6059402, 0xa6059502, 0xa6059602, 0xa6059702, + 0xa6059802, 0xa6059902, 0xa6059a02, 0xa6059b02, 0xa6059c02, 0xa6059d02, 0xa6059e02, 0xa6059f02, + 0xa605a002, 0xa605a102, 0xa605a202, 0xa605a302, 0xa605a402, 0xa605a502, 0xa605a602, 0xa605a702, + 0xa605a802, 0xa605a902, 0xa605aa02, 0xa605ab02, 0xa605ac02, 0xa605ad02, 0xa605ae02, 0xa605af02, + 0xa605b002, 0xa605b102, 0xa605b202, 0xa605b302, 0xa605b402, 0xa605b502, 0xa605b602, 0xa605b702, + 0xa605b802, 0xa605b902, 0xa605ba02, 0xa605bb02, 0xa605bc02, 0xa605bd02, 0xa605be02, 0xa605bf02, + 0xa605c002, 0xa605c102, 0xa605c202, 0xa605c302, 0xa605c402, 0xa605c502, 0xa605c602, 0xa605c702, + 0xa605c802, 0xa605c902, 0xa605ca02, 0xa605cb02, 0xa605cc02, 0xa605cd02, 0xa605ce02, 0xa605cf02, + 0xa605d002, 0xa605d102, 0xa605d202, 0xa605d302, 0xa605d402, 0xa605d502, 0xa605d602, 0xa605d702, + 0xa605d802, 0xa605d902, 0xa605da02, 0xa605db02, 0xa605dc02, 0xa605dd02, 0xa605de02, 0xa605df02, + 0xa605e002, 0xa605e102, 0xa605e202, 0xa605e302, 0xa605e402, 0xa605e502, 0xa605e602, 0xa605e702, + 0xa605e802, 0xa605e902, 0xa605ea02, 0xa605eb02, 0xa605ec02, 0xa605ed02, 0xa605ee02, 0xa605ef02, + 0xa605f002, 0xa605f102, 0xa605f202, 0xa605f302, 0xa605f402, 0xa605f502, 0xa605f602, 0xa605f702, + 0xa605f802, 0xa605f902, 0xa605fa02, 0xa605fb02, 0xa605fc02, 0xa605fd02, 0xa605fe02, 0xa605ff02, + 0xa7050202, 0xa7050302, 0xa7050402, 0xa7050502, 0xa7050602, 0xa7050702, 0xa7050802, 0xa7050902, + 0xa7050a02, 0xa7050b02, 0xa7050c02, 0xa7050d02, 0xa7050e02, 0xa7050f02, 0xa7051002, 0xa7051102, + 0xa7051202, 0xa7051302, 0xa7051402, 0xa7051502, 0xa7051602, 0xa7051702, 0xa7051802, 0xa7051902, + 0xa7051a02, 0xa7051b02, 0xa7051c02, 0xa7051d02, 0xa7051e02, 0xa7051f02, 0xa7052002, 0xa7052102, + 0xa7052202, 0xa7052302, 0xa7052402, 0xa7052502, 0xa7052602, 0xa7052702, 0xa7052802, 0xa7052902, + 0xa7052a02, 0xa7052b02, 0xa7052c02, 0xa7052d02, 0xa7052e02, 0xa7052f02, 0xa7053002, 0xa7053102, + 0xa7053202, 0xa7053302, 0xa7053402, 0xa7053502, 0xa7053602, 0xa7053702, 0xa7053802, 0xa7053902, + 0xa7053a02, 0xa7053b02, 0xa7053c02, 0xa7053d02, 0xa7053e02, 0xa7053f02, 0xa7054002, 0xa7054102, + 0xa7054202, 0xa7054302, 0xa7054402, 0xa7054502, 0xa7054602, 0xa7054702, 0xa7054802, 0xa7054902, + 0xa7054a02, 0xa7054b02, 0xa7054c02, 0xa7054d02, 0xa7054e02, 0xa7054f02, 0xa7055002, 0xa7055102, + 0xa7055202, 0xa7055302, 0xa7055402, 0xa7055502, 0xa7055602, 0xa7055702, 0xa7055802, 0xa7055902, + 0xa7055a02, 0xa7055b02, 0xa7055c02, 0xa7055d02, 0xa7055e02, 0xa7055f02, 0xa7056002, 0xa7056102, + 0xa7056202, 0xa7056302, 0xa7056402, 0xa7056502, 0xa7056602, 0xa7056702, 0xa7056802, 0xa7056902, + 0xa7056a02, 0xa7056b02, 0xa7056c02, 0xa7056d02, 0xa7056e02, 0xa7056f02, 0xa7057002, 0xa7057102, + 0xa7057202, 0xa7057302, 0xa7057402, 0xa7057502, 0xa7057602, 0xa7057702, 0xa7057802, 0xa7057902, + 0xa7057a02, 0xa7057b02, 0xa7057c02, 0xa7057d02, 0xa7057e02, 0xa7057f02, 0xa7058002, 0xa7058102, + 0xa7058202, 0xa7058302, 0xa7058402, 0xa7058502, 0xa7058602, 0xa7058702, 0xa7058802, 0xa7058902, + 0xa7058a02, 0xa7058b02, 0xa7058c02, 0xa7058d02, 0xa7058e02, 0xa7058f02, 0xa7059002, 0xa7059102, + 0xa7059202, 0xa7059302, 0xa7059402, 0xa7059502, 0xa7059602, 0xa7059702, 0xa7059802, 0xa7059902, + 0xa7059a02, 0xa7059b02, 0xa7059c02, 0xa7059d02, 0xa7059e02, 0xa7059f02, 0xa705a002, 0xa705a102, + 0xa705a202, 0xa705a302, 0xa705a402, 0xa705a502, 0xa705a602, 0xa705a702, 0xa705a802, 0xa705a902, + 0xa705aa02, 0xa705ab02, 0xa705ac02, 0xa705ad02, 0xa705ae02, 0xa705af02, 0xa705b002, 0xa705b102, + 0xa705b202, 0xa705b302, 0xa705b402, 0xa705b502, 0xa705b602, 0xa705b702, 0xa705b802, 0xa705b902, + 0xa705ba02, 0xa705bb02, 0xa705bc02, 0xa705bd02, 0xa705be02, 0xa705bf02, 0xa705c002, 0xa705c102, + 0xa705c202, 0xa705c302, 0xa705c402, 0xa705c502, 0xa705c602, 0xa705c702, 0xa705c802, 0xa705c902, + 0xa705ca02, 0xa705cb02, 0xa705cc02, 0xa705cd02, 0xa705ce02, 0xa705cf02, 0xa705d002, 0xa705d102, + 0xa705d202, 0xa705d302, 0xa705d402, 0xa705d502, 0xa705d602, 0xa705d702, 0xa705d802, 0xa705d902, + 0xa705da02, 0xa705db02, 0xa705dc02, 0xa705dd02, 0xa705de02, 0xa705df02, 0xa705e002, 0xa705e102, + 0xa705e202, 0xa705e302, 0xa705e402, 0xa705e502, 0xa705e602, 0xa705e702, 0xa705e802, 0xa705e902, + 0xa705ea02, 0xa705eb02, 0xa705ec02, 0xa705ed02, 0xa705ee02, 0xa705ef02, 0xa705f002, 0xa705f102, + 0xa705f202, 0xa705f302, 0xa705f402, 0xa705f502, 0xa705f602, 0xa705f702, 0xa705f802, 0xa705f902, + 0xa705fa02, 0xa705fb02, 0xa705fc02, 0xa705fd02, 0xa705fe02, 0xa705ff02, 0xa8050202, 0xa8050302, + 0xa8050402, 0xa8050502, 0xa8050602, 0xa8050702, 0xa8050802, 0xa8050902, 0xa8050a02, 0xa8050b02, + 0xa8050c02, 0xa8050d02, 0xa8050e02, 0xa8050f02, 0xa8051002, 0xa8051102, 0xa8051202, 0xa8051302, + 0xa8051402, 0xa8051502, 0xa8051602, 0xa8051702, 0xa8051802, 0xa8051902, 0xa8051a02, 0xa8051b02, + 0xa8051c02, 0xa8051d02, 0xa8051e02, 0xa8051f02, 0xa8052002, 0xa8052102, 0xa8052202, 0xa8052302, + 0xa8052402, 0xa8052502, 0xa8052602, 0xa8052702, 0xa8052802, 0xa8052902, 0xa8052a02, 0xa8052b02, + 0xa8052c02, 0xa8052d02, 0xa8052e02, 0xa8052f02, 0xa8053002, 0xa8053102, 0xa8053202, 0xa8053302, + 0xa8053402, 0xa8053502, 0xa8053602, 0xa8053702, 0xa8053802, 0xa8053902, 0xa8053a02, 0xa8053b02, + 0xa8053c02, 0xa8053d02, 0xa8053e02, 0xa8053f02, 0xa8054002, 0xa8054102, 0xa8054202, 0xa8054302, + 0xa8054402, 0xa8054502, 0xa8054602, 0xa8054702, 0xa8054802, 0xa8054902, 0xa8054a02, 0xa8054b02, + 0xa8054c02, 0xa8054d02, 0xa8054e02, 0xa8054f02, 0xa8055002, 0xa8055102, 0xa8055202, 0xa8055302, + 0xa8055402, 0xa8055502, 0xa8055602, 0xa8055702, 0xa8055802, 0xa8055902, 0xa8055a02, 0xa8055b02, + 0xa8055c02, 0xa8055d02, 0xa8055e02, 0xa8055f02, 0xa8056002, 0xa8056102, 0xa8056202, 0xa8056302, + 0xa8056402, 0xa8056502, 0xa8056602, 0xa8056702, 0xa8056802, 0xa8056902, 0xa8056a02, 0xa8056b02, + 0xa8056c02, 0xa8056d02, 0xa8056e02, 0xa8056f02, 0xa8057002, 0xa8057102, 0xa8057202, 0xa8057302, + 0xa8057402, 0xa8057502, 0xa8057602, 0xa8057702, 0xa8057802, 0xa8057902, 0xa8057a02, 0xa8057b02, + 0xa8057c02, 0xa8057d02, 0xa8057e02, 0xa8057f02, 0xa8058002, 0xa8058102, 0xa8058202, 0xa8058302, + 0xa8058402, 0xa8058502, 0xa8058602, 0xa8058702, 0xa8058802, 0xa8058902, 0xa8058a02, 0xa8058b02, + 0xa8058c02, 0xa8058d02, 0xa8058e02, 0xa8058f02, 0xa8059002, 0xa8059102, 0xa8059202, 0xa8059302, + 0xa8059402, 0xa8059502, 0xa8059602, 0xa8059702, 0xa8059802, 0xa8059902, 0xa8059a02, 0xa8059b02, + 0xa8059c02, 0xa8059d02, 0xa8059e02, 0xa8059f02, 0xa805a002, 0xa805a102, 0xa805a202, 0xa805a302, + 0xa805a402, 0xa805a502, 0xa805a602, 0xa805a702, 0xa805a802, 0xa805a902, 0xa805aa02, 0xa805ab02, + 0xa805ac02, 0xa805ad02, 0xa805ae02, 0xa805af02, 0xa805b002, 0xa805b102, 0xa805b202, 0xa805b302, + 0xa805b402, 0xa805b502, 0xa805b602, 0xa805b702, 0xa805b802, 0xa805b902, 0xa805ba02, 0xa805bb02, + 0xa805bc02, 0xa805bd02, 0xa805be02, 0xa805bf02, 0xa805c002, 0xa805c102, 0xa805c202, 0xa805c302, + 0xa805c402, 0xa805c502, 0xa805c602, 0xa805c702, 0xa805c802, 0xa805c902, 0xa805ca02, 0xa805cb02, + 0xa805cc02, 0xa805cd02, 0xa805ce02, 0xa805cf02, 0xa805d002, 0xa805d102, 0xa805d202, 0xa805d302, + 0xa805d402, 0xa805d502, 0xa805d602, 0xa805d702, 0xa805d802, 0xa805d902, 0xa805da02, 0xa805db02, + 0xa805dc02, 0xa805dd02, 0xa805de02, 0xa805df02, 0xa805e002, 0xa805e102, 0xa805e202, 0xa805e302, + 0xa805e402, 0xa805e502, 0xa805e602, 0xa805e702, 0xa805e802, 0xa805e902, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x02a80202, 0x03a80202, 0x04a80202, 0x05a80202, 0x06a80202, 0x07a80202, 0x08a80202, 0x09a80202, + 0x0aa80202, 0x0ba80202, 0x0ca80202, 0x0da80202, 0x0ea80202, 0x0fa80202, 0x10a80202, 0x11a80202, + 0x12a80202, 0x13a80202, 0x14a80202, 0x15a80202, 0x16a80202, 0x17a80202, 0x18a80202, 0x19a80202, + 0x1aa80202, 0x1ba80202, 0x1ca80202, 0x1da80202, 0x1ea80202, 0x1fa80202, 0x20a80202, 0x21a80202, + 0x22a80202, 0x23a80202, 0x24a80202, 0x25a80202, 0x26a80202, 0x27a80202, 0x28a80202, 0x29a80202, + 0x2aa80202, 0x2ba80202, 0x2ca80202, 0x2da80202, 0x2ea80202, 0x2fa80202, 0x30a80202, 0x31a80202, + 0x32a80202, 0x33a80202, 0x34a80202, 0x35a80202, 0x36a80202, 0x37a80202, 0x38a80202, 0x39a80202, + 0x3aa80202, 0x3ba80202, 0x3ca80202, 0x3da80202, 0x3ea80202, 0x3fa80202, 0x40a80202, 0x41a80202, + 0x3c056a02, 0x3c056b02, 0x3c056c02, 0x3c056d02, 0x3c056e02, 0x3c056f02, 0x3c057002, 0x3c057102, + 0x3c057202, 0x3c057302, 0x3c057402, 0x3c057502, 0x3c057602, 0x3c057702, 0x3c057802, 0x3c057902, + 0x3c057a02, 0x3c057b02, 0x3c057c02, 0x3c057d02, 0x3c057e02, 0x3c057f02, 0x3c058002, 0x3c058102, + 0x3c058202, 0x3c058302, 0x3c058402, 0x3c058502, 0x3c058602, 0x3c058702, 0x3c058802, 0x3c058902, + 0x3c058a02, 0x3c058b02, 0x3c058c02, 0x3c058d02, 0x3c058e02, 0x3c058f02, 0x3c059002, 0x3c059102, + 0x3c059202, 0x3c059302, 0x3c059402, 0x3c059502, 0x3c059602, 0x3c059702, 0x3c059802, 0x3c059902, + 0x3c059a02, 0x3c059b02, 0x3c059c02, 0x3c059d02, 0x3c059e02, 0x3c059f02, 0x3c05a002, 0x3c05a102, + 0x3c05a202, 0x3c05a302, 0x3c05a402, 0x3c05a502, 0x3c05a602, 0x3c05a702, 0x3c05a802, 0x3c05a902, + 0x3c05aa02, 0x3c05ab02, 0x3c05ac02, 0x3c05ad02, 0x3c05ae02, 0x3c05af02, 0x3c05b002, 0x3c05b102, + 0x3c05b202, 0x3c05b302, 0x3c05b402, 0x3c05b502, 0x3c05b602, 0x3c05b702, 0x3c05b802, 0x3c05b902, + 0x3c05ba02, 0x3c05bb02, 0x3c05bc02, 0x3c05bd02, 0x3c05be02, 0x3c05bf02, 0x3c05c002, 0x3c05c102, + 0x3c05c202, 0x3c05c302, 0x3c05c402, 0x3c05c502, 0x3c05c602, 0x3c05c702, 0x3c05c802, 0x3c05c902, + 0x3c05ca02, 0x3c05cb02, 0x3c05cc02, 0x3c05cd02, 0x3c05ce02, 0x3c05cf02, 0x3c05d002, 0x3c05d102, + 0x3c05d202, 0x3c05d302, 0x3c05d402, 0x3c05d502, 0x3c05d602, 0x3c05d702, 0x3c05d802, 0x3c05d902, + 0x3c05da02, 0x3c05db02, 0x3c05dc02, 0x3c05dd02, 0x3c05de02, 0x3c05df02, 0x3c05e002, 0x3c05e102, + 0x3c05e202, 0x3c05e302, 0x3c05e402, 0x3c05e502, 0x3c05e602, 0x3c05e702, 0x3c05e802, 0x3c05e902, + 0x3c05ea02, 0x3c05eb02, 0x3c05ec02, 0x3c05ed02, 0x3c05ee02, 0x3c05ef02, 0x3c05f002, 0x3c05f102, + 0x3c05f202, 0x3c05f302, 0x3c05f402, 0x3c05f502, 0x3c05f602, 0x3c05f702, 0x3c05f802, 0x3c05f902, + 0x3c05fa02, 0x3c05fb02, 0x3c05fc02, 0x3c05fd02, 0x3c05fe02, 0x3c05ff02, 0x3d050202, 0x3d050302, + 0x3d050402, 0x3d050502, 0x3d050602, 0x3d050702, 0x3d050802, 0x3d050902, 0x3d050a02, 0x3d050b02, + 0x3d050c02, 0x3d050d02, 0x3d050e02, 0x3d050f02, 0x3d051002, 0x3d051102, 0x3d051202, 0x3d051302, + 0x3d051402, 0x3d051502, 0x3d051602, 0x3d051702, 0x3d051802, 0x3d051902, 0x3d051a02, 0x3d051b02, + 0x3d051c02, 0x3d051d02, 0x3d051e02, 0x3d051f02, 0x3d052002, 0x3d052102, 0x3d052202, 0x3d052302, + 0x3d052402, 0x3d052502, 0x3d052602, 0x3d052702, 0x3d052802, 0x3d052902, 0x3d052a02, 0x3d052b02, + 0x3d052c02, 0x3d052d02, 0x3d052e02, 0x3d052f02, 0x3d053002, 0x3d053102, 0x3d053202, 0x3d053302, + 0x3d053402, 0x3d053502, 0x3d053602, 0x3d053702, 0x3d053802, 0x3d053902, 0x3d053a02, 0x3d053b02, + 0x3d053c02, 0x3d053d02, 0x3d053e02, 0x3d053f02, 0x3d054002, 0x3d054102, 0x3d054202, 0x3d054302, + 0x3d054402, 0x3d054502, 0x3d054602, 0x3d054702, 0x3d054802, 0x3d054902, 0x3d054a02, 0x3d054b02, + 0x3d054c02, 0x3d054d02, 0x3d054e02, 0x3d054f02, 0x3d055002, 0x3d055102, 0x3d055202, 0x3d055302, + 0x3d055402, 0x3d055502, 0x3d055602, 0x3d055702, 0x3d055802, 0x3d055902, 0x3d055a02, 0x3d055b02, + 0x3d055c02, 0x3d055d02, 0x3d055e02, 0x3d055f02, 0x3d056002, 0x3d056102, 0x3d056202, 0x3d056302, + 0x3d056402, 0x3d056502, 0x3d056602, 0x3d056702, 0x3d056802, 0x3d056902, 0x3d056a02, 0x3d056b02, + 0x3d056c02, 0x3d056d02, 0x3d056e02, 0x3d056f02, 0x3d057002, 0x3d057102, 0x3d057202, 0x3d057302, + 0x3d057402, 0x3d057502, 0x3d057602, 0x3d057702, 0x3d057802, 0x3d057902, 0x3d057a02, 0x3d057b02, + 0x3d057c02, 0x3d057d02, 0x3d057e02, 0x3d057f02, 0x3d058002, 0x3d058102, 0x3d058202, 0x3d058302, + 0x3d058402, 0x3d058502, 0x3d058602, 0x3d058702, 0x3d058802, 0x3d058902, 0x3d058a02, 0x3d058b02, + 0x3d058c02, 0x3d058d02, 0x3d058e02, 0x3d058f02, 0x3d059002, 0x3d059102, 0x3d059202, 0x3d059302, + 0x3d059402, 0x3d059502, 0x3d059602, 0x3d059702, 0x3d059802, 0x3d059902, 0x3d059a02, 0x3d059b02, + 0x3d059c02, 0x3d059d02, 0x3d059e02, 0x3d059f02, 0x3d05a002, 0x3d05a102, 0x3d05a202, 0x3d05a302, + 0x3d05a402, 0x3d05a502, 0x3d05a602, 0x3d05a702, 0x3d05a802, 0x3d05a902, 0x3d05aa02, 0x3d05ab02, + 0x3d05ac02, 0x3d05ad02, 0x3d05ae02, 0x3d05af02, 0x3d05b002, 0x3d05b102, 0x3d05b202, 0x3d05b302, + 0x3d05b402, 0x3d05b502, 0x3d05b602, 0x3d05b702, 0x3d05b802, 0x3d05b902, 0x3d05ba02, 0x3d05bb02, + 0x3d05bc02, 0x3d05bd02, 0x3d05be02, 0x3d05bf02, 0x3d05c002, 0x3d05c102, 0x3d05c202, 0x3d05c302, + 0x3d05c402, 0x3d05c502, 0x3d05c602, 0x3d05c702, 0x3d05c802, 0x3d05c902, 0x3d05ca02, 0x3d05cb02, + 0x3d05cc02, 0x3d05cd02, 0x3d05ce02, 0x3d05cf02, 0x3d05d002, 0x3d05d102, 0x3d05d202, 0x3d05d302, + 0x3d05d402, 0x3d05d502, 0x3d05d602, 0x3d05d702, 0x3d05d802, 0x3d05d902, 0x3d05da02, 0x3d05db02, + 0x3d05dc02, 0x3d05dd02, 0x3d05de02, 0x3d05df02, 0x3d05e002, 0x3d05e102, 0x3d05e202, 0x3d05e302, + 0x3d05e402, 0x3d05e502, 0x3d05e602, 0x3d05e702, 0x3d05e802, 0x3d05e902, 0x3d05ea02, 0x3d05eb02, + 0x3d05ec02, 0x3d05ed02, 0x3d05ee02, 0x3d05ef02, 0x3d05f002, 0x3d05f102, 0x3d05f202, 0x3d05f302, + 0x3d05f402, 0x3d05f502, 0x3d05f602, 0x3d05f702, 0x3d05f802, 0x3d05f902, 0x3d05fa02, 0x3d05fb02, + 0x3d05fc02, 0x3d05fd02, 0x3d05fe02, 0x3d05ff02, 0x3e050202, 0x3e050302, 0x3e050402, 0x3e050502, + 0x3e050602, 0x3e050702, 0x3e050802, 0x3e050902, 0x3e050a02, 0x3e050b02, 0x3e050c02, 0x3e050d02, + 0x3e050e02, 0x3e050f02, 0x3e051002, 0x3e051102, 0x3e051202, 0x3e051302, 0x3e051402, 0x3e051502, + 0x3e051602, 0x3e051702, 0x3e051802, 0x3e051902, 0x3e051a02, 0x3e051b02, 0x3e051c02, 0x3e051d02, + 0x3e051e02, 0x3e051f02, 0x3e052002, 0x3e052102, 0x3e052202, 0x3e052302, 0x3e052402, 0x3e052502, + 0x3e052602, 0x3e052702, 0x3e052802, 0x3e052902, 0x3e052a02, 0x3e052b02, 0x3e052c02, 0x3e052d02, + 0x3e052e02, 0x3e052f02, 0x3e053002, 0x3e053102, 0x3e053202, 0x3e053302, 0x3e053402, 0x3e053502, + 0x3e053602, 0x3e053702, 0x3e053802, 0x3e053902, 0x3e053a02, 0x3e053b02, 0x3e053c02, 0x3e053d02, + 0x3e053e02, 0x3e053f02, 0x3e054002, 0x3e054102, 0x3e054202, 0x3e054302, 0x3e054402, 0x3e054502, + 0x3e054602, 0x3e054702, 0x3e054802, 0x3e054902, 0x3e054a02, 0x3e054b02, 0x3e054c02, 0x3e054d02, + 0x3e054e02, 0x3e054f02, 0x3e055002, 0x3e055102, 0x3e055202, 0x3e055302, 0x3e055402, 0x3e055502, + 0x3e055602, 0x3e055702, 0x3e055802, 0x3e055902, 0x3e055a02, 0x3e055b02, 0x3e055c02, 0x3e055d02, + 0x3e055e02, 0x3e055f02, 0x3e056002, 0x3e056102, 0x3e056202, 0x3e056302, 0x3e056402, 0x3e056502, + 0x3e056602, 0x3e056702, 0x3e056802, 0x3e056902, 0x3e056a02, 0x3e056b02, 0x3e056c02, 0x3e056d02, + 0x3e056e02, 0x3e056f02, 0x3e057002, 0x3e057102, 0x3e057202, 0x3e057302, 0x3e057402, 0x3e057502, + 0x3e057602, 0x3e057702, 0x3e057802, 0x3e057902, 0x3e057a02, 0x3e057b02, 0x3e057c02, 0x3e057d02, + 0x3e057e02, 0x3e057f02, 0x3e058002, 0x3e058102, 0x3e058202, 0x3e058302, 0x3e058402, 0x3e058502, + 0x3e058602, 0x3e058702, 0x3e058802, 0x3e058902, 0x3e058a02, 0x3e058b02, 0x3e058c02, 0x3e058d02, + 0x3e058e02, 0x3e058f02, 0x3e059002, 0x3e059102, 0x3e059202, 0x3e059302, 0x3e059402, 0x3e059502, + 0x3e059602, 0x3e059702, 0x3e059802, 0x3e059902, 0x3e059a02, 0x3e059b02, 0x3e059c02, 0x3e059d02, + 0x3e059e02, 0x3e059f02, 0x3e05a002, 0x3e05a102, 0x3e05a202, 0x3e05a302, 0x3e05a402, 0x3e05a502, + 0x3e05a602, 0x3e05a702, 0x3e05a802, 0x3e05a902, 0x3e05aa02, 0x3e05ab02, 0x3e05ac02, 0x3e05ad02, + 0x3e05ae02, 0x3e05af02, 0x3e05b002, 0x3e05b102, 0x3e05b202, 0x3e05b302, 0x3e05b402, 0x3e05b502, + 0x3e05b602, 0x3e05b702, 0x3e05b802, 0x3e05b902, 0x3e05ba02, 0x3e05bb02, 0x3e05bc02, 0x3e05bd02, + 0x3e05be02, 0x3e05bf02, 0x3e05c002, 0x3e05c102, 0x3e05c202, 0x3e05c302, 0x3e05c402, 0x3e05c502, + 0x3e05c602, 0x3e05c702, 0x3e05c802, 0x3e05c902, 0x3e05ca02, 0x3e05cb02, 0x3e05cc02, 0x3e05cd02, + 0x3e05ce02, 0x3e05cf02, 0x3e05d002, 0x3e05d102, 0x3e05d202, 0x3e05d302, 0x3e05d402, 0x3e05d502, + 0x3e05d602, 0x3e05d702, 0x3e05d802, 0x3e05d902, 0x3e05da02, 0x3e05db02, 0x3e05dc02, 0x3e05dd02, + 0x3e05de02, 0x3e05df02, 0x3e05e002, 0x3e05e102, 0x3e05e202, 0x3e05e302, 0x3e05e402, 0x3e05e502, + 0x3e05e602, 0x3e05e702, 0x3e05e802, 0x3e05e902, 0x3e05ea02, 0x3e05eb02, 0x3e05ec02, 0x3e05ed02, + 0x3e05ee02, 0x3e05ef02, 0x3e05f002, 0x3e05f102, 0x3e05f202, 0x3e05f302, 0x3e05f402, 0x3e05f502, + 0x3e05f602, 0x3e05f702, 0x3e05f802, 0x3e05f902, 0x3e05fa02, 0x3e05fb02, 0x3e05fc02, 0x3e05fd02, + 0x3e05fe02, 0x3e05ff02, 0x3f050202, 0x3f050302, 0x3f050402, 0x3f050502, 0x3f050602, 0x3f050702, + 0x3f050802, 0x3f050902, 0x3f050a02, 0x3f050b02, 0x3f050c02, 0x3f050d02, 0x3f050e02, 0x3f050f02, + 0x3f051002, 0x3f051102, 0x3f051202, 0x3f051302, 0x3f051402, 0x3f051502, 0x3f051602, 0x3f051702, + 0x3f051802, 0x3f051902, 0x3f051a02, 0x3f051b02, 0x3f051c02, 0x3f051d02, 0x3f051e02, 0x3f051f02, + 0x3f052002, 0x3f052102, 0x3f052202, 0x3f052302, 0x3f052402, 0x3f052502, 0x3f052602, 0x3f052702, + 0x3f052802, 0x3f052902, 0x3f052a02, 0x3f052b02, 0x3f052c02, 0x3f052d02, 0x3f052e02, 0x3f052f02, + 0x3f053002, 0x3f053102, 0x3f053202, 0x3f053302, 0x3f053402, 0x3f053502, 0x3f053602, 0x3f053702, + 0x3f053802, 0x3f053902, 0x3f053a02, 0x3f053b02, 0x3f053c02, 0x3f053d02, 0x3f053e02, 0x3f053f02, + 0x3f054002, 0x3f054102, 0x3f054202, 0x3f054302, 0x3f054402, 0x3f054502, 0x3f054602, 0x3f054702, + 0x3f054802, 0x3f054902, 0x3f054a02, 0x3f054b02, 0x3f054c02, 0x3f054d02, 0x3f054e02, 0x3f054f02, + 0x3f055002, 0x3f055102, 0x3f055202, 0x3f055302, 0x3f055402, 0x3f055502, 0x3f055602, 0x3f055702, + 0x3f055802, 0x3f055902, 0x3f055a02, 0x3f055b02, 0x3f055c02, 0x3f055d02, 0x3f055e02, 0x3f055f02, + 0x3f056002, 0x3f056102, 0x3f056202, 0x3f056302, 0x3f056402, 0x3f056502, 0x3f056602, 0x3f056702, + 0x3f056802, 0x3f056902, 0x3f056a02, 0x3f056b02, 0x3f056c02, 0x3f056d02, 0x3f056e02, 0x3f056f02, + 0x3f057002, 0x3f057102, 0x3f057202, 0x3f057302, 0x3f057402, 0x3f057502, 0x3f057602, 0x3f057702, + 0x3f057802, 0x3f057902, 0x3f057a02, 0x3f057b02, 0x3f057c02, 0x3f057d02, 0x3f057e02, 0x3f057f02, + 0x3f058002, 0x3f058102, 0x3f058202, 0x3f058302, 0x3f058402, 0x3f058502, 0x3f058602, 0x3f058702, + 0x3f058802, 0x3f058902, 0x3f058a02, 0x3f058b02, 0x3f058c02, 0x3f058d02, 0x3f058e02, 0x3f058f02, + 0x3f059002, 0x3f059102, 0x3f059202, 0x3f059302, 0x3f059402, 0x3f059502, 0x3f059602, 0x3f059702, + 0x3f059802, 0x3f059902, 0x3f059a02, 0x3f059b02, 0x3f059c02, 0x3f059d02, 0x3f059e02, 0x3f059f02, + 0x3f05a002, 0x3f05a102, 0x3f05a202, 0x3f05a302, 0x3f05a402, 0x3f05a502, 0x3f05a602, 0x3f05a702, + 0x3f05a802, 0x3f05a902, 0x3f05aa02, 0x3f05ab02, 0x3f05ac02, 0x3f05ad02, 0x3f05ae02, 0x3f05af02, + 0x3f05b002, 0x3f05b102, 0x3f05b202, 0x3f05b302, 0x3f05b402, 0x3f05b502, 0x3f05b602, 0x3f05b702, + 0x3f05b802, 0x3f05b902, 0x3f05ba02, 0x3f05bb02, 0x3f05bc02, 0x3f05bd02, 0x3f05be02, 0x3f05bf02, + 0x3f05c002, 0x3f05c102, 0x3f05c202, 0x3f05c302, 0x3f05c402, 0x3f05c502, 0x3f05c602, 0x3f05c702, + 0x3f05c802, 0x3f05c902, 0x3f05ca02, 0x3f05cb02, 0x3f05cc02, 0x3f05cd02, 0x3f05ce02, 0x3f05cf02, + 0x3f05d002, 0x3f05d102, 0x3f05d202, 0x3f05d302, 0x3f05d402, 0x3f05d502, 0x3f05d602, 0x3f05d702, + 0x3f05d802, 0x3f05d902, 0x3f05da02, 0x3f05db02, 0x3f05dc02, 0x3f05dd02, 0x3f05de02, 0x3f05df02, + 0x3f05e002, 0x3f05e102, 0x3f05e202, 0x3f05e302, 0x3f05e402, 0x3f05e502, 0x3f05e602, 0x3f05e702, + 0x3f05e802, 0x3f05e902, 0x3f05ea02, 0x3f05eb02, 0x3f05ec02, 0x3f05ed02, 0x3f05ee02, 0x3f05ef02, + 0x3f05f002, 0x3f05f102, 0x3f05f202, 0x3f05f302, 0x3f05f402, 0x3f05f502, 0x3f05f602, 0x3f05f702, + 0x3f05f802, 0x3f05f902, 0x3f05fa02, 0x3f05fb02, 0x3f05fc02, 0x3f05fd02, 0x3f05fe02, 0x3f05ff02, + 0x40050202, 0x40050302, 0x40050402, 0x40050502, 0x40050602, 0x40050702, 0x40050802, 0x40050902, + 0x40050a02, 0x40050b02, 0x40050c02, 0x40050d02, 0x40050e02, 0x40050f02, 0x40051002, 0x40051102, + 0x40051202, 0x40051302, 0x40051402, 0x40051502, 0x40051602, 0x40051702, 0x40051802, 0x40051902, + 0x40051a02, 0x40051b02, 0x40051c02, 0x40051d02, 0x40051e02, 0x40051f02, 0x40052002, 0x40052102, + 0x40052202, 0x40052302, 0x40052402, 0x40052502, 0x40052602, 0x40052702, 0x40052802, 0x40052902, + 0x40052a02, 0x40052b02, 0x40052c02, 0x40052d02, 0x40052e02, 0x40052f02, 0x40053002, 0x40053102, + 0x40053202, 0x40053302, 0x40053402, 0x40053502, 0x40053602, 0x40053702, 0x40053802, 0x40053902, + 0x40053a02, 0x40053b02, 0x40053c02, 0x40053d02, 0x40053e02, 0x40053f02, 0x40054002, 0x40054102, + 0x40054202, 0x40054302, 0x40054402, 0x40054502, 0x40054602, 0x40054702, 0x40054802, 0x40054902, + 0x40054a02, 0x40054b02, 0x40054c02, 0x40054d02, 0x40054e02, 0x40054f02, 0x40055002, 0x40055102, + 0x40055202, 0x40055302, 0x40055402, 0x40055502, 0x40055602, 0x40055702, 0x40055802, 0x40055902, + 0x40055a02, 0x40055b02, 0x40055c02, 0x40055d02, 0x40055e02, 0x40055f02, 0x40056002, 0x40056102, + 0x40056202, 0x40056302, 0x40056402, 0x40056502, 0x40056602, 0x40056702, 0x40056802, 0x40056902, + 0x40056a02, 0x40056b02, 0x40056c02, 0x40056d02, 0x40056e02, 0x40056f02, 0x40057002, 0x40057102, + 0x40057202, 0x40057302, 0x40057402, 0x40057502, 0x40057602, 0x40057702, 0x40057802, 0x40057902, + 0x40057a02, 0x40057b02, 0x40057c02, 0x40057d02, 0x40057e02, 0x40057f02, 0x40058002, 0x40058102, + 0x40058202, 0x40058302, 0x40058402, 0x40058502, 0x40058602, 0x40058702, 0x40058802, 0x40058902, + 0x40058a02, 0x40058b02, 0x40058c02, 0x40058d02, 0x40058e02, 0x40058f02, 0x40059002, 0x40059102, + 0x40059202, 0x40059302, 0x40059402, 0x40059502, 0x40059602, 0x40059702, 0x40059802, 0x40059902, + 0x40059a02, 0x40059b02, 0x40059c02, 0x40059d02, 0x40059e02, 0x40059f02, 0x4005a002, 0x4005a102, + 0x4005a202, 0x4005a302, 0x4005a402, 0x4005a502, 0x4005a602, 0x4005a702, 0x4005a802, 0x4005a902, + 0x4005aa02, 0x4005ab02, 0x4005ac02, 0x4005ad02, 0x4005ae02, 0x4005af02, 0x4005b002, 0x4005b102, + 0x4005b202, 0x4005b302, 0x4005b402, 0x4005b502, 0x4005b602, 0x4005b702, 0x4005b802, 0x4005b902, + 0x4005ba02, 0x4005bb02, 0x4005bc02, 0x4005bd02, 0x4005be02, 0x4005bf02, 0x4005c002, 0x4005c102, + 0x4005c202, 0x4005c302, 0x4005c402, 0x4005c502, 0x4005c602, 0x4005c702, 0x4005c802, 0x4005c902, + 0x4005ca02, 0x4005cb02, 0x4005cc02, 0x4005cd02, 0x4005ce02, 0x4005cf02, 0x4005d002, 0x4005d102, + 0x4005d202, 0x4005d302, 0x4005d402, 0x4005d502, 0x4005d602, 0x4005d702, 0x4005d802, 0x4005d902, + 0x4005da02, 0x4005db02, 0x4005dc02, 0x4005dd02, 0x4005de02, 0x4005df02, 0x4005e002, 0x4005e102, + 0x4005e202, 0x4005e302, 0x4005e402, 0x4005e502, 0x4005e602, 0x4005e702, 0x4005e802, 0x4005e902, + 0x4005ea02, 0x4005eb02, 0x4005ec02, 0x4005ed02, 0x4005ee02, 0x4005ef02, 0x4005f002, 0x4005f102, + 0x4005f202, 0x4005f302, 0x4005f402, 0x4005f502, 0x4005f602, 0x4005f702, 0x4005f802, 0x4005f902, + 0x4005fa02, 0x4005fb02, 0x4005fc02, 0x4005fd02, 0x4005fe02, 0x4005ff02, 0x41050202, 0x41050302, + 0x41050402, 0x41050502, 0x41050602, 0x41050702, 0x41050802, 0x41050902, 0x41050a02, 0x41050b02, + 0x41050c02, 0x41050d02, 0x41050e02, 0x41050f02, 0x41051002, 0x41051102, 0x41051202, 0x41051302, + 0x41051402, 0x41051502, 0x41051602, 0x41051702, 0x41051802, 0x41051902, 0x41051a02, 0x41051b02, + 0x41051c02, 0x41051d02, 0x41051e02, 0x41051f02, 0x41052002, 0x41052102, 0x41052202, 0x41052302, + 0x41052402, 0x41052502, 0x41052602, 0x41052702, 0x41052802, 0x41052902, 0x41052a02, 0x41052b02, + 0x41052c02, 0x41052d02, 0x41052e02, 0x41052f02, 0x41053002, 0x41053102, 0x41053202, 0x41053302, + 0x41053402, 0x41053502, 0x41053602, 0x41053702, 0x41053802, 0x41053902, 0x41053a02, 0x41053b02, + 0x41053c02, 0x41053d02, 0x41053e02, 0x41053f02, 0x41054002, 0x41054102, 0x41054202, 0x41054302, + 0x41054402, 0x41054502, 0x41054602, 0x41054702, 0x41054802, 0x41054902, 0x41054a02, 0x41054b02, + 0x41054c02, 0x41054d02, 0x41054e02, 0x41054f02, 0x41055002, 0x41055102, 0x41055202, 0x41055302, + 0x41055402, 0x41055502, 0x41055602, 0x41055702, 0x41055802, 0x41055902, 0x41055a02, 0x41055b02, + 0x41055c02, 0x41055d02, 0x41055e02, 0x41055f02, 0x41056002, 0x41056102, 0x41056202, 0x41056302, + 0x41056402, 0x41056502, 0x41056602, 0x41056702, 0x41056802, 0x41056902, 0x41056a02, 0x41056b02, + 0x41056c02, 0x41056d02, 0x41056e02, 0x41056f02, 0x41057002, 0x41057102, 0x41057202, 0x41057302, + 0x41057402, 0x41057502, 0x41057602, 0x41057702, 0x41057802, 0x41057902, 0x41057a02, 0x41057b02, + 0x41057c02, 0x41057d02, 0x41057e02, 0x41057f02, 0x41058002, 0x41058102, 0x41058202, 0x41058302, + 0x41058402, 0x41058502, 0x41058602, 0x41058702, 0x41058802, 0x41058902, 0x41058a02, 0x41058b02, + 0x41058c02, 0x41058d02, 0x41058e02, 0x41058f02, 0x41059002, 0x41059102, 0x41059202, 0x41059302, + 0x41059402, 0x41059502, 0x41059602, 0x41059702, 0x41059802, 0x41059902, 0x41059a02, 0x41059b02, + 0x41059c02, 0x41059d02, 0x41059e02, 0x41059f02, 0x4105a002, 0x4105a102, 0x4105a202, 0x4105a302, + 0x4105a402, 0x4105a502, 0x4105a602, 0x4105a702, 0x4105a802, 0x4105a902, 0x4105aa02, 0x4105ab02, + 0x4105ac02, 0x4105ad02, 0x4105ae02, 0x4105af02, 0x4105b002, 0x4105b102, 0x4105b202, 0x4105b302, + 0x4105b402, 0x4105b502, 0x4105b602, 0x4105b702, 0x4105b802, 0x4105b902, 0x4105ba02, 0x4105bb02, + 0x4105bc02, 0x4105bd02, 0x4105be02, 0x4105bf02, 0x4105c002, 0x4105c102, 0x4105c202, 0x4105c302, + 0x4105c402, 0x4105c502, 0x4105c602, 0x4105c702, 0x4105c802, 0x4105c902, 0x4105ca02, 0x4105cb02, + 0x4105cc02, 0x4105cd02, 0x4105ce02, 0x4105cf02, 0x4105d002, 0x4105d102, 0x4105d202, 0x4105d302, + 0x4105d402, 0x4105d502, 0x4105d602, 0x4105d702, 0x4105d802, 0x4105d902, 0x4105da02, 0x4105db02, + 0x4105dc02, 0x4105dd02, 0x4105de02, 0x4105df02, 0x4105e002, 0x4105e102, 0x4105e202, 0x4105e302, + 0x4105e402, 0x4105e502, 0x4105e602, 0x4105e702, 0x4105e802, 0x4105e902, 0x4105ea02, 0x4105eb02, + 0x4105ec02, 0x4105ed02, 0x4105ee02, 0x4105ef02, 0x4105f002, 0x4105f102, 0x4105f202, 0x4105f302, + 0x4105f402, 0x4105f502, 0x4105f602, 0x4105f702, 0x4105f802, 0x4105f902, 0x4105fa02, 0x4105fb02, + 0x4105fc02, 0x4105fd02, 0x4105fe02, 0x4105ff02, 0x42050202, 0x42050302, 0x42050402, 0x42050502, + 0x42050602, 0x42050702, 0x42050802, 0x42050902, 0x42050a02, 0x42050b02, 0x42050c02, 0x42050d02, + 0x42050e02, 0x42050f02, 0x42051002, 0x42051102, 0x42051202, 0x42051302, 0x42051402, 0x42051502, + 0x42051602, 0x42051702, 0x42051802, 0x42051902, 0x42051a02, 0x42051b02, 0x42051c02, 0x42051d02, + 0x42051e02, 0x42051f02, 0x42052002, 0x42052102, 0x42052202, 0x42052302, 0x42052402, 0x42052502, + 0x42052602, 0x42052702, 0x42052802, 0x42052902, 0x42052a02, 0x42052b02, 0x42052c02, 0x42052d02, + 0x42052e02, 0x42052f02, 0x42053002, 0x42053102, 0x42053202, 0x42053302, 0x42053402, 0x42053502, + 0x42053602, 0x42053702, 0x42053802, 0x42053902, 0x42053a02, 0x42053b02, 0x42053c02, 0x42053d02, + 0x42053e02, 0x42053f02, 0x42054002, 0x42054102, 0x42054202, 0x42054302, 0x42054402, 0x42054502, + 0x42054602, 0x42054702, 0x42054802, 0x42054902, 0x42054a02, 0x42054b02, 0x42054c02, 0x42054d02, + 0x42054e02, 0x42054f02, 0x42055002, 0x42055102, 0x42055202, 0x42055302, 0x42055402, 0x42055502, + 0x42055602, 0x42055702, 0x42055802, 0x42055902, 0x42055a02, 0x42055b02, 0x42055c02, 0x42055d02, + 0x42055e02, 0x42055f02, 0x42056002, 0x42056102, 0x42056202, 0x42056302, 0x42056402, 0x42056502, + 0x42056602, 0x42056702, 0x42056802, 0x42056902, 0x42056a02, 0x42056b02, 0x42056c02, 0x42056d02, + 0x42056e02, 0x42056f02, 0x42057002, 0x42057102, 0x42057202, 0x42057302, 0x42057402, 0x42057502, + 0x42057602, 0x42057702, 0x42057802, 0x42057902, 0x42057a02, 0x42057b02, 0x42057c02, 0x42057d02, + 0x42057e02, 0x42057f02, 0x42058002, 0x42058102, 0x42058202, 0x42058302, 0x42058402, 0x42058502, + 0x42058602, 0x42058702, 0x42058802, 0x42058902, 0x42058a02, 0x42058b02, 0x42058c02, 0x42058d02, + 0x42058e02, 0x42058f02, 0x42059002, 0x42059102, 0x42059202, 0x42059302, 0x42059402, 0x42059502, + 0x42059602, 0x42059702, 0x42059802, 0x42059902, 0x42059a02, 0x42059b02, 0x42059c02, 0x42059d02, + 0x42059e02, 0x42059f02, 0x4205a002, 0x4205a102, 0x4205a202, 0x4205a302, 0x4205a402, 0x4205a502, + 0x4205a602, 0x4205a702, 0x4205a802, 0x4205a902, 0x4205aa02, 0x4205ab02, 0x4205ac02, 0x4205ad02, + 0x4205ae02, 0x4205af02, 0x4205b002, 0x4205b102, 0x4205b202, 0x4205b302, 0x4205b402, 0x4205b502, + 0x4205b602, 0x4205b702, 0x4205b802, 0x4205b902, 0x4205ba02, 0x4205bb02, 0x4205bc02, 0x4205bd02, + 0x4205be02, 0x4205bf02, 0x4205c002, 0x4205c102, 0x4205c202, 0x4205c302, 0x4205c402, 0x4205c502, + 0x4205c602, 0x4205c702, 0x4205c802, 0x4205c902, 0x4205ca02, 0x4205cb02, 0x4205cc02, 0x4205cd02, + 0x4205ce02, 0x4205cf02, 0x4205d002, 0x4205d102, 0x4205d202, 0x4205d302, 0x4205d402, 0x4205d502, + 0x4205d602, 0x4205d702, 0x4205d802, 0x4205d902, 0x4205da02, 0x4205db02, 0x4205dc02, 0x4205dd02, + 0x4205de02, 0x4205df02, 0x4205e002, 0x4205e102, 0x4205e202, 0x4205e302, 0x4205e402, 0x4205e502, + 0x4205e602, 0x4205e702, 0x4205e802, 0x4205e902, 0x4205ea02, 0x4205eb02, 0x4205ec02, 0x4205ed02, + 0x4205ee02, 0x4205ef02, 0x4205f002, 0x4205f102, 0x4205f202, 0x4205f302, 0x4205f402, 0x4205f502, + 0x4205f602, 0x4205f702, 0x4205f802, 0x4205f902, 0x4205fa02, 0x4205fb02, 0x4205fc02, 0x4205fd02, + 0x4205fe02, 0x4205ff02, 0x43050202, 0x43050302, 0x43050402, 0x43050502, 0x43050602, 0x43050702, + 0x43050802, 0x43050902, 0x43050a02, 0x43050b02, 0x43050c02, 0x43050d02, 0x43050e02, 0x43050f02, + 0x43051002, 0x43051102, 0x43051202, 0x43051302, 0x43051402, 0x43051502, 0x43051602, 0x43051702, + 0x43051802, 0x43051902, 0x43051a02, 0x43051b02, 0x43051c02, 0x43051d02, 0x43051e02, 0x43051f02, + 0x43052002, 0x43052102, 0x43052202, 0x43052302, 0x43052402, 0x43052502, 0x43052602, 0x43052702, + 0x43052802, 0x43052902, 0x43052a02, 0x43052b02, 0x43052c02, 0x43052d02, 0x43052e02, 0x43052f02, + 0x43053002, 0x43053102, 0x43053202, 0x43053302, 0x43053402, 0x43053502, 0x43053602, 0x43053702, + 0x43053802, 0x43053902, 0x43053a02, 0x43053b02, 0x43053c02, 0x43053d02, 0x43053e02, 0x43053f02, + 0x43054002, 0x43054102, 0x43054202, 0x43054302, 0x43054402, 0x43054502, 0x43054602, 0x43054702, + 0x43054802, 0x43054902, 0x43054a02, 0x43054b02, 0x43054c02, 0x43054d02, 0x43054e02, 0x43054f02, + 0x43055002, 0x43055102, 0x43055202, 0x43055302, 0x43055402, 0x43055502, 0x43055602, 0x43055702, + 0x43055802, 0x43055902, 0x43055a02, 0x43055b02, 0x43055c02, 0x43055d02, 0x43055e02, 0x43055f02, + 0x43056002, 0x43056102, 0x43056202, 0x43056302, 0x43056402, 0x43056502, 0x43056602, 0x43056702, + 0x43056802, 0x43056902, 0x43056a02, 0x43056b02, 0x43056c02, 0x43056d02, 0x43056e02, 0x43056f02, + 0x43057002, 0x43057102, 0x43057202, 0x43057302, 0x43057402, 0x43057502, 0x43057602, 0x43057702, + 0x43057802, 0x43057902, 0x43057a02, 0x43057b02, 0x43057c02, 0x43057d02, 0x43057e02, 0x43057f02, + 0x43058002, 0x43058102, 0x43058202, 0x43058302, 0x43058402, 0x43058502, 0x43058602, 0x43058702, + 0x43058802, 0x43058902, 0x43058a02, 0x43058b02, 0x43058c02, 0x43058d02, 0x43058e02, 0x43058f02, + 0x43059002, 0x43059102, 0x43059202, 0x43059302, 0x43059402, 0x43059502, 0x43059602, 0x43059702, + 0x43059802, 0x43059902, 0x43059a02, 0x43059b02, 0x43059c02, 0x43059d02, 0x43059e02, 0x43059f02, + 0x4305a002, 0x4305a102, 0x4305a202, 0x4305a302, 0x4305a402, 0x4305a502, 0x4305a602, 0x4305a702, + 0x4305a802, 0x4305a902, 0x4305aa02, 0x4305ab02, 0x4305ac02, 0x4305ad02, 0x4305ae02, 0x4305af02, + 0x4305b002, 0x4305b102, 0x4305b202, 0x4305b302, 0x4305b402, 0x4305b502, 0x4305b602, 0x4305b702, + 0x4305b802, 0x4305b902, 0x4305ba02, 0x4305bb02, 0x4305bc02, 0x4305bd02, 0x4305be02, 0x4305bf02, + 0x4305c002, 0x4305c102, 0x4305c202, 0x4305c302, 0x4305c402, 0x4305c502, 0x4305c602, 0x4305c702, + 0x4305c802, 0x4305c902, 0x4305ca02, 0x4305cb02, 0x4305cc02, 0x4305cd02, 0x4305ce02, 0x4305cf02, + 0x4305d002, 0x4305d102, 0x4305d202, 0x4305d302, 0x4305d402, 0x4305d502, 0x4305d602, 0x4305d702, + 0x4305d802, 0x4305d902, 0x4305da02, 0x4305db02, 0x4305dc02, 0x4305dd02, 0x4305de02, 0x4305df02, + 0x4305e002, 0x4305e102, 0x4305e202, 0x4305e302, 0x4305e402, 0x4305e502, 0x4305e602, 0x4305e702, + 0x4305e802, 0x4305e902, 0x4305ea02, 0x4305eb02, 0x4305ec02, 0x4305ed02, 0x4305ee02, 0x4305ef02, + 0x4305f002, 0x4305f102, 0x4305f202, 0x4305f302, 0x4305f402, 0x4305f502, 0x4305f602, 0x4305f702, + 0x4305f802, 0x4305f902, 0x4305fa02, 0x4305fb02, 0x4305fc02, 0x4305fd02, 0x4305fe02, 0x4305ff02, + 0x44050202, 0x44050302, 0x44050402, 0x44050502, 0x44050602, 0x44050702, 0x44050802, 0x44050902, + 0x44050a02, 0x44050b02, 0x44050c02, 0x44050d02, 0x44050e02, 0x44050f02, 0x44051002, 0x44051102, + 0x44051202, 0x44051302, 0x44051402, 0x44051502, 0x44051602, 0x44051702, 0x44051802, 0x44051902, + 0x44051a02, 0x44051b02, 0x44051c02, 0x44051d02, 0x44051e02, 0x44051f02, 0x44052002, 0x44052102, + 0x44052202, 0x44052302, 0x44052402, 0x44052502, 0x44052602, 0x44052702, 0x44052802, 0x44052902, + 0x44052a02, 0x44052b02, 0x44052c02, 0x44052d02, 0x44052e02, 0x44052f02, 0x44053002, 0x44053102, + 0x44053202, 0x44053302, 0x44053402, 0x44053502, 0x44053602, 0x44053702, 0x44053802, 0x44053902, + 0x44053a02, 0x44053b02, 0x44053c02, 0x44053d02, 0x44053e02, 0x44053f02, 0x44054002, 0x44054102, + 0x44054202, 0x44054302, 0x44054402, 0x44054502, 0x44054602, 0x44054702, 0x44054802, 0x44054902, + 0x44054a02, 0x44054b02, 0x44054c02, 0x44054d02, 0x44054e02, 0x44054f02, 0x44055002, 0x44055102, + 0x44055202, 0x44055302, 0x44055402, 0x44055502, 0x44055602, 0x44055702, 0x44055802, 0x44055902, + 0x44055a02, 0x44055b02, 0x44055c02, 0x44055d02, 0x44055e02, 0x44055f02, 0x44056002, 0x44056102, + 0x44056202, 0x44056302, 0x44056402, 0x44056502, 0x44056602, 0x44056702, 0x44056802, 0x44056902, + 0x44056a02, 0x44056b02, 0x44056c02, 0x44056d02, 0x44056e02, 0x44056f02, 0x44057002, 0x44057102, + 0x44057202, 0x44057302, 0x44057402, 0x44057502, 0x44057602, 0x44057702, 0x44057802, 0x44057902, + 0x44057a02, 0x44057b02, 0x44057c02, 0x44057d02, 0x44057e02, 0x44057f02, 0x44058002, 0x44058102, + 0x44058202, 0x44058302, 0x44058402, 0x44058502, 0x44058602, 0x44058702, 0x44058802, 0x44058902, + 0x44058a02, 0x44058b02, 0x44058c02, 0x44058d02, 0x44058e02, 0x44058f02, 0x44059002, 0x44059102, + 0x44059202, 0x44059302, 0x44059402, 0x44059502, 0x44059602, 0x44059702, 0x44059802, 0x44059902, + 0x44059a02, 0x44059b02, 0x44059c02, 0x44059d02, 0x44059e02, 0x44059f02, 0x4405a002, 0x4405a102, + 0x4405a202, 0x4405a302, 0x4405a402, 0x4405a502, 0x4405a602, 0x4405a702, 0x4405a802, 0x4405a902, + 0x4405aa02, 0x4405ab02, 0x4405ac02, 0x4405ad02, 0x4405ae02, 0x4405af02, 0x4405b002, 0x4405b102, + 0x4405b202, 0x4405b302, 0x4405b402, 0x4405b502, 0x4405b602, 0x4405b702, 0x4405b802, 0x4405b902, + 0x4405ba02, 0x4405bb02, 0x4405bc02, 0x4405bd02, 0x4405be02, 0x4405bf02, 0x4405c002, 0x4405c102, + 0x4405c202, 0x4405c302, 0x4405c402, 0x4405c502, 0x4405c602, 0x4405c702, 0x4405c802, 0x4405c902, + 0x4405ca02, 0x4405cb02, 0x4405cc02, 0x4405cd02, 0x4405ce02, 0x4405cf02, 0x4405d002, 0x4405d102, + 0x4405d202, 0x4405d302, 0x4405d402, 0x4405d502, 0x4405d602, 0x4405d702, 0x4405d802, 0x4405d902, + 0x4405da02, 0x4405db02, 0x4405dc02, 0x4405dd02, 0x4405de02, 0x4405df02, 0x4405e002, 0x4405e102, + 0x4405e202, 0x4405e302, 0x4405e402, 0x4405e502, 0x4405e602, 0x4405e702, 0x4405e802, 0x4405e902, + 0x4405ea02, 0x4405eb02, 0x4405ec02, 0x4405ed02, 0x4405ee02, 0x4405ef02, 0x4405f002, 0x4405f102, + 0x4405f202, 0x4405f302, 0x4405f402, 0x4405f502, 0x4405f602, 0x4405f702, 0x4405f802, 0x4405f902, + 0x4405fa02, 0x4405fb02, 0x4405fc02, 0x4405fd02, 0x4405fe02, 0x4405ff02, 0x45050202, 0x45050302, + 0x45050402, 0x45050502, 0x45050602, 0x45050702, 0x45050802, 0x45050902, 0x45050a02, 0x45050b02, + 0x45050c02, 0x45050d02, 0x45050e02, 0x45050f02, 0x45051002, 0x45051102, 0x45051202, 0x45051302, + 0x45051402, 0x45051502, 0x45051602, 0x45051702, 0x45051802, 0x45051902, 0x45051a02, 0x45051b02, + 0x45051c02, 0x45051d02, 0x45051e02, 0x45051f02, 0x45052002, 0x45052102, 0x45052202, 0x45052302, + 0x45052402, 0x45052502, 0x45052602, 0x45052702, 0x45052802, 0x45052902, 0x45052a02, 0x45052b02, + 0x45052c02, 0x45052d02, 0x45052e02, 0x45052f02, 0x45053002, 0x45053102, 0x45053202, 0x45053302, + 0x45053402, 0x45053502, 0x45053602, 0x45053702, 0x45053802, 0x45053902, 0x45053a02, 0x45053b02, + 0x45053c02, 0x45053d02, 0x45053e02, 0x45053f02, 0x45054002, 0x45054102, 0x45054202, 0x45054302, + 0x45054402, 0x45054502, 0x45054602, 0x45054702, 0x45054802, 0x45054902, 0x45054a02, 0x45054b02, + 0x45054c02, 0x45054d02, 0x45054e02, 0x45054f02, 0x45055002, 0x45055102, 0x45055202, 0x45055302, + 0x45055402, 0x45055502, 0x45055602, 0x45055702, 0x45055802, 0x45055902, 0x45055a02, 0x45055b02, + 0x45055c02, 0x45055d02, 0x45055e02, 0x45055f02, 0x45056002, 0x45056102, 0x45056202, 0x45056302, + 0x45056402, 0x45056502, 0x45056602, 0x45056702, 0x45056802, 0x45056902, 0x45056a02, 0x45056b02, + 0x45056c02, 0x45056d02, 0x45056e02, 0x45056f02, 0x45057002, 0x45057102, 0x45057202, 0x45057302, + 0x45057402, 0x45057502, 0x45057602, 0x45057702, 0x45057802, 0x45057902, 0x45057a02, 0x45057b02, + 0x45057c02, 0x45057d02, 0x45057e02, 0x45057f02, 0x45058002, 0x45058102, 0x45058202, 0x45058302, + 0x45058402, 0x45058502, 0x45058602, 0x45058702, 0x45058802, 0x45058902, 0x45058a02, 0x45058b02, + 0x45058c02, 0x45058d02, 0x45058e02, 0x45058f02, 0x45059002, 0x45059102, 0x45059202, 0x45059302, + 0x45059402, 0x45059502, 0x45059602, 0x45059702, 0x45059802, 0x45059902, 0x45059a02, 0x45059b02, + 0x45059c02, 0x45059d02, 0x45059e02, 0x45059f02, 0x4505a002, 0x4505a102, 0x4505a202, 0x4505a302, + 0x4505a402, 0x4505a502, 0x4505a602, 0x4505a702, 0x4505a802, 0x4505a902, 0x4505aa02, 0x4505ab02, + 0x4505ac02, 0x4505ad02, 0x4505ae02, 0x4505af02, 0x4505b002, 0x4505b102, 0x4505b202, 0x4505b302, + 0x4505b402, 0x4505b502, 0x4505b602, 0x4505b702, 0x4505b802, 0x4505b902, 0x4505ba02, 0x4505bb02, + 0x4505bc02, 0x4505bd02, 0x4505be02, 0x4505bf02, 0x4505c002, 0x4505c102, 0x4505c202, 0x4505c302, + 0x4505c402, 0x4505c502, 0x4505c602, 0x4505c702, 0x4505c802, 0x4505c902, 0x4505ca02, 0x4505cb02, + 0x4505cc02, 0x4505cd02, 0x4505ce02, 0x4505cf02, 0x4505d002, 0x4505d102, 0x4505d202, 0x4505d302, + 0x4505d402, 0x4505d502, 0x4505d602, 0x4505d702, 0x4505d802, 0x4505d902, 0x4505da02, 0x4505db02, + 0x4505dc02, 0x4505dd02, 0x4505de02, 0x4505df02, 0x4505e002, 0x4505e102, 0x4505e202, 0x4505e302, + 0x4505e402, 0x4505e502, 0x4505e602, 0x4505e702, 0x4505e802, 0x4505e902, 0x4505ea02, 0x4505eb02, + 0x4505ec02, 0x4505ed02, 0x4505ee02, 0x4505ef02, 0x4505f002, 0x4505f102, 0x4505f202, 0x4505f302, + 0x4505f402, 0x4505f502, 0x4505f602, 0x4505f702, 0x4505f802, 0x4505f902, 0x4505fa02, 0x4505fb02, + 0x4505fc02, 0x4505fd02, 0x4505fe02, 0x4505ff02, 0x46050202, 0x46050302, 0x46050402, 0x46050502, + 0x46050602, 0x46050702, 0x46050802, 0x46050902, 0x46050a02, 0x46050b02, 0x46050c02, 0x46050d02, + 0x46050e02, 0x46050f02, 0x46051002, 0x46051102, 0x46051202, 0x46051302, 0x46051402, 0x46051502, + 0x46051602, 0x46051702, 0x46051802, 0x46051902, 0x46051a02, 0x46051b02, 0x46051c02, 0x46051d02, + 0x46051e02, 0x46051f02, 0x46052002, 0x46052102, 0x46052202, 0x46052302, 0x46052402, 0x46052502, + 0x46052602, 0x46052702, 0x46052802, 0x46052902, 0x46052a02, 0x46052b02, 0x46052c02, 0x46052d02, + 0x46052e02, 0x46052f02, 0x46053002, 0x46053102, 0x46053202, 0x46053302, 0x46053402, 0x46053502, + 0x46053602, 0x46053702, 0x46053802, 0x46053902, 0x46053a02, 0x46053b02, 0x46053c02, 0x46053d02, + 0x46053e02, 0x46053f02, 0x46054002, 0x46054102, 0x46054202, 0x46054302, 0x46054402, 0x46054502, + 0x46054602, 0x46054702, 0x46054802, 0x46054902, 0x46054a02, 0x46054b02, 0x46054c02, 0x46054d02, + 0x46054e02, 0x46054f02, 0x46055002, 0x46055102, 0x46055202, 0x46055302, 0x46055402, 0x46055502, + 0x46055602, 0x46055702, 0x46055802, 0x46055902, 0x46055a02, 0x46055b02, 0x46055c02, 0x46055d02, + 0x46055e02, 0x46055f02, 0x46056002, 0x46056102, 0x46056202, 0x46056302, 0x46056402, 0x46056502, + 0x46056602, 0x46056702, 0x46056802, 0x46056902, 0x46056a02, 0x46056b02, 0x46056c02, 0x46056d02, + 0x46056e02, 0x46056f02, 0x46057002, 0x46057102, 0x46057202, 0x46057302, 0x46057402, 0x46057502, + 0x46057602, 0x46057702, 0x46057802, 0x46057902, 0x46057a02, 0x46057b02, 0x46057c02, 0x46057d02, + 0x46057e02, 0x46057f02, 0x46058002, 0x46058102, 0x46058202, 0x46058302, 0x46058402, 0x46058502, + 0x46058602, 0x46058702, 0x46058802, 0x46058902, 0x46058a02, 0x46058b02, 0x46058c02, 0x46058d02, + 0x46058e02, 0x46058f02, 0x46059002, 0x46059102, 0x46059202, 0x46059302, 0x46059402, 0x46059502, + 0x46059602, 0x46059702, 0x46059802, 0x46059902, 0x46059a02, 0x46059b02, 0x46059c02, 0x46059d02, + 0x46059e02, 0x46059f02, 0x4605a002, 0x4605a102, 0x4605a202, 0x4605a302, 0x4605a402, 0x4605a502, + 0x4605a602, 0x4605a702, 0x4605a802, 0x4605a902, 0x4605aa02, 0x4605ab02, 0x4605ac02, 0x4605ad02, + 0x4605ae02, 0x4605af02, 0x4605b002, 0x4605b102, 0x4605b202, 0x4605b302, 0x4605b402, 0x4605b502, + 0x4605b602, 0x4605b702, 0x4605b802, 0x4605b902, 0x4605ba02, 0x4605bb02, 0x4605bc02, 0x4605bd02, + 0x4605be02, 0x4605bf02, 0x4605c002, 0x4605c102, 0x4605c202, 0x4605c302, 0x4605c402, 0x4605c502, + 0x4605c602, 0x4605c702, 0x4605c802, 0x4605c902, 0x4605ca02, 0x4605cb02, 0x4605cc02, 0x4605cd02, + 0x4605ce02, 0x4605cf02, 0x4605d002, 0x4605d102, 0x4605d202, 0x4605d302, 0x4605d402, 0x4605d502, + 0x4605d602, 0x4605d702, 0x4605d802, 0x4605d902, 0x4605da02, 0x4605db02, 0x4605dc02, 0x4605dd02, + 0x4605de02, 0x4605df02, 0x4605e002, 0x4605e102, 0x4605e202, 0x4605e302, 0x4605e402, 0x4605e502, + 0x4605e602, 0x4605e702, 0x4605e802, 0x4605e902, 0x4605ea02, 0x4605eb02, 0x4605ec02, 0x4605ed02, + 0x4605ee02, 0x4605ef02, 0x4605f002, 0x4605f102, 0x4605f202, 0x4605f302, 0x4605f402, 0x4605f502, + 0x4605f602, 0x4605f702, 0x4605f802, 0x4605f902, 0x4605fa02, 0x4605fb02, 0x4605fc02, 0x4605fd02, + 0x4605fe02, 0x4605ff02, 0x47050202, 0x47050302, 0x47050402, 0x47050502, 0x47050602, 0x47050702, + 0x47050802, 0x47050902, 0x47050a02, 0x47050b02, 0x47050c02, 0x47050d02, 0x47050e02, 0x47050f02, + 0x47051002, 0x47051102, 0x47051202, 0x47051302, 0x47051402, 0x47051502, 0x47051602, 0x47051702, + 0x47051802, 0x47051902, 0x47051a02, 0x47051b02, 0x47051c02, 0x47051d02, 0x47051e02, 0x47051f02, + 0x47052002, 0x47052102, 0x47052202, 0x47052302, 0x47052402, 0x47052502, 0x47052602, 0x47052702, + 0x47052802, 0x47052902, 0x47052a02, 0x47052b02, 0x47052c02, 0x47052d02, 0x47052e02, 0x47052f02, + 0x47053002, 0x47053102, 0x47053202, 0x47053302, 0x47053402, 0x47053502, 0x47053602, 0x47053702, + 0x47053802, 0x47053902, 0x47053a02, 0x47053b02, 0x47053c02, 0x47053d02, 0x47053e02, 0x47053f02, + 0x47054002, 0x47054102, 0x47054202, 0x47054302, 0x47054402, 0x47054502, 0x47054602, 0x47054702, + 0x47054802, 0x47054902, 0x47054a02, 0x47054b02, 0x47054c02, 0x47054d02, 0x47054e02, 0x47054f02, + 0x47055002, 0x47055102, 0x47055202, 0x47055302, 0x47055402, 0x47055502, 0x47055602, 0x47055702, + 0x47055802, 0x47055902, 0x47055a02, 0x47055b02, 0x47055c02, 0x47055d02, 0x47055e02, 0x47055f02, + 0x47056002, 0x47056102, 0x47056202, 0x47056302, 0x47056402, 0x47056502, 0x47056602, 0x47056702, + 0x47056802, 0x47056902, 0x47056a02, 0x47056b02, 0x47056c02, 0x47056d02, 0x47056e02, 0x47056f02, + 0x47057002, 0x47057102, 0x47057202, 0x47057302, 0x47057402, 0x47057502, 0x47057602, 0x47057702, + 0x47057802, 0x47057902, 0x47057a02, 0x47057b02, 0x47057c02, 0x47057d02, 0x47057e02, 0x47057f02, + 0x47058002, 0x47058102, 0x47058202, 0x47058302, 0x47058402, 0x47058502, 0x47058602, 0x47058702, + 0x47058802, 0x47058902, 0x47058a02, 0x47058b02, 0x47058c02, 0x47058d02, 0x47058e02, 0x47058f02, + 0x47059002, 0x47059102, 0x47059202, 0x47059302, 0x47059402, 0x47059502, 0x47059602, 0x47059702, + 0x47059802, 0x47059902, 0x47059a02, 0x47059b02, 0x47059c02, 0x47059d02, 0x47059e02, 0x47059f02, + 0x4705a002, 0x4705a102, 0x4705a202, 0x4705a302, 0x4705a402, 0x4705a502, 0x4705a602, 0x4705a702, + 0x4705a802, 0x4705a902, 0x4705aa02, 0x4705ab02, 0x4705ac02, 0x4705ad02, 0x4705ae02, 0x4705af02, + 0x4705b002, 0x4705b102, 0x4705b202, 0x4705b302, 0x4705b402, 0x4705b502, 0x4705b602, 0x4705b702, + 0x4705b802, 0x4705b902, 0x4705ba02, 0x4705bb02, 0x4705bc02, 0x4705bd02, 0x4705be02, 0x4705bf02, + 0x4705c002, 0x4705c102, 0x4705c202, 0x4705c302, 0x4705c402, 0x4705c502, 0x4705c602, 0x4705c702, + 0x4705c802, 0x4705c902, 0x4705ca02, 0x4705cb02, 0x4705cc02, 0x4705cd02, 0x4705ce02, 0x4705cf02, + 0x4705d002, 0x4705d102, 0x4705d202, 0x4705d302, 0x4705d402, 0x4705d502, 0x4705d602, 0x4705d702, + 0x4705d802, 0x4705d902, 0x4705da02, 0x4705db02, 0x4705dc02, 0x4705dd02, 0x4705de02, 0x4705df02, + 0x4705e002, 0x4705e102, 0x4705e202, 0x4705e302, 0x4705e402, 0x4705e502, 0x4705e602, 0x4705e702, + 0x4705e802, 0x4705e902, 0x4705ea02, 0x4705eb02, 0x4705ec02, 0x4705ed02, 0x4705ee02, 0x4705ef02, + 0x4705f002, 0x4705f102, 0x4705f202, 0x4705f302, 0x4705f402, 0x4705f502, 0x4705f602, 0x4705f702, + 0x4705f802, 0x4705f902, 0x4705fa02, 0x4705fb02, 0x4705fc02, 0x4705fd02, 0x4705fe02, 0x4705ff02, + 0x48050202, 0x48050302, 0x48050402, 0x48050502, 0x48050602, 0x48050702, 0x48050802, 0x48050902, + 0x48050a02, 0x48050b02, 0x48050c02, 0x48050d02, 0x48050e02, 0x48050f02, 0x48051002, 0x48051102, + 0x48051202, 0x48051302, 0x48051402, 0x48051502, 0x48051602, 0x48051702, 0x48051802, 0x48051902, + 0x48051a02, 0x48051b02, 0x48051c02, 0x48051d02, 0x48051e02, 0x48051f02, 0x48052002, 0x48052102, + 0x48052202, 0x48052302, 0x48052402, 0x48052502, 0x48052602, 0x48052702, 0x48052802, 0x48052902, + 0x48052a02, 0x48052b02, 0x48052c02, 0x48052d02, 0x48052e02, 0x48052f02, 0x48053002, 0x48053102, + 0x48053202, 0x48053302, 0x48053402, 0x48053502, 0x48053602, 0x48053702, 0x48053802, 0x48053902, + 0x48053a02, 0x48053b02, 0x48053c02, 0x48053d02, 0x48053e02, 0x48053f02, 0x48054002, 0x48054102, + 0x48054202, 0x48054302, 0x48054402, 0x48054502, 0x48054602, 0x48054702, 0x48054802, 0x48054902, + 0x48054a02, 0x48054b02, 0x48054c02, 0x48054d02, 0x48054e02, 0x48054f02, 0x48055002, 0x48055102, + 0x48055202, 0x48055302, 0x48055402, 0x48055502, 0x48055602, 0x48055702, 0x48055802, 0x48055902, + 0x48055a02, 0x48055b02, 0x48055c02, 0x48055d02, 0x48055e02, 0x48055f02, 0x48056002, 0x48056102, + 0x48056202, 0x48056302, 0x48056402, 0x48056502, 0x48056602, 0x48056702, 0x48056802, 0x48056902, + 0x48056a02, 0x48056b02, 0x48056c02, 0x48056d02, 0x48056e02, 0x48056f02, 0x48057002, 0x48057102, + 0x48057202, 0x48057302, 0x48057402, 0x48057502, 0x48057602, 0x48057702, 0x48057802, 0x48057902, + 0x48057a02, 0x48057b02, 0x48057c02, 0x48057d02, 0x48057e02, 0x48057f02, 0x48058002, 0x48058102, + 0x48058202, 0x48058302, 0x48058402, 0x48058502, 0x48058602, 0x48058702, 0x48058802, 0x48058902, + 0x48058a02, 0x48058b02, 0x48058c02, 0x48058d02, 0x48058e02, 0x48058f02, 0x48059002, 0x48059102, + 0x48059202, 0x48059302, 0x48059402, 0x48059502, 0x48059602, 0x48059702, 0x48059802, 0x48059902, + 0x48059a02, 0x48059b02, 0x48059c02, 0x48059d02, 0x48059e02, 0x48059f02, 0x4805a002, 0x4805a102, + 0x4805a202, 0x4805a302, 0x4805a402, 0x4805a502, 0x4805a602, 0x4805a702, 0x4805a802, 0x4805a902, + 0x4805aa02, 0x4805ab02, 0x4805ac02, 0x4805ad02, 0x4805ae02, 0x4805af02, 0x4805b002, 0x4805b102, + 0x4805b202, 0x4805b302, 0x4805b402, 0x4805b502, 0x4805b602, 0x4805b702, 0x4805b802, 0x4805b902, + 0x4805ba02, 0x4805bb02, 0x4805bc02, 0x4805bd02, 0x4805be02, 0x4805bf02, 0x4805c002, 0x4805c102, + 0x4805c202, 0x4805c302, 0x4805c402, 0x4805c502, 0x4805c602, 0x4805c702, 0x4805c802, 0x4805c902, + 0x4805ca02, 0x4805cb02, 0x4805cc02, 0x4805cd02, 0x4805ce02, 0x4805cf02, 0x4805d002, 0x4805d102, + 0x4805d202, 0x4805d302, 0x4805d402, 0x4805d502, 0x4805d602, 0x4805d702, 0x4805d802, 0x4805d902, + 0x4805da02, 0x4805db02, 0x4805dc02, 0x4805dd02, 0x4805de02, 0x4805df02, 0x4805e002, 0x4805e102, + 0x4805e202, 0x4805e302, 0x4805e402, 0x4805e502, 0x4805e602, 0x4805e702, 0x4805e802, 0x4805e902, + 0x4805ea02, 0x4805eb02, 0x4805ec02, 0x4805ed02, 0x4805ee02, 0x4805ef02, 0x4805f002, 0x4805f102, + 0x4805f202, 0x4805f302, 0x4805f402, 0x4805f502, 0x4805f602, 0x4805f702, 0x4805f802, 0x4805f902, + 0x4805fa02, 0x4805fb02, 0x4805fc02, 0x4805fd02, 0x4805fe02, 0x4805ff02, 0x49050202, 0x49050302, + 0x49050402, 0x49050502, 0x49050602, 0x49050702, 0x49050802, 0x49050902, 0x49050a02, 0x49050b02, + 0x49050c02, 0x49050d02, 0x49050e02, 0x49050f02, 0x49051002, 0x49051102, 0x49051202, 0x49051302, + 0x49051402, 0x49051502, 0x49051602, 0x49051702, 0x49051802, 0x49051902, 0x49051a02, 0x49051b02, + 0x49051c02, 0x49051d02, 0x49051e02, 0x49051f02, 0x49052002, 0x49052102, 0x49052202, 0x49052302, + 0x49052402, 0x49052502, 0x49052602, 0x49052702, 0x49052802, 0x49052902, 0x49052a02, 0x49052b02, + 0x49052c02, 0x49052d02, 0x49052e02, 0x49052f02, 0x49053002, 0x49053102, 0x49053202, 0x49053302, + 0x49053402, 0x49053502, 0x49053602, 0x49053702, 0x49053802, 0x49053902, 0x49053a02, 0x49053b02, + 0x49053c02, 0x49053d02, 0x49053e02, 0x49053f02, 0x49054002, 0x49054102, 0x49054202, 0x49054302, + 0x49054402, 0x49054502, 0x49054602, 0x49054702, 0x49054802, 0x49054902, 0x49054a02, 0x49054b02, + 0x49054c02, 0x49054d02, 0x49054e02, 0x49054f02, 0x49055002, 0x49055102, 0x49055202, 0x49055302, + 0x49055402, 0x49055502, 0x49055602, 0x49055702, 0x49055802, 0x49055902, 0x49055a02, 0x49055b02, + 0x49055c02, 0x49055d02, 0x49055e02, 0x49055f02, 0x49056002, 0x49056102, 0x49056202, 0x49056302, + 0x49056402, 0x49056502, 0x49056602, 0x49056702, 0x49056802, 0x49056902, 0x49056a02, 0x49056b02, + 0x49056c02, 0x49056d02, 0x49056e02, 0x49056f02, 0x49057002, 0x49057102, 0x49057202, 0x49057302, + 0x49057402, 0x49057502, 0x49057602, 0x49057702, 0x49057802, 0x49057902, 0x49057a02, 0x49057b02, + 0x49057c02, 0x49057d02, 0x49057e02, 0x49057f02, 0x49058002, 0x49058102, 0x49058202, 0x49058302, + 0x49058402, 0x49058502, 0x49058602, 0x49058702, 0x49058802, 0x49058902, 0x49058a02, 0x49058b02, + 0x49058c02, 0x49058d02, 0x49058e02, 0x49058f02, 0x49059002, 0x49059102, 0x49059202, 0x49059302, + 0x49059402, 0x49059502, 0x49059602, 0x49059702, 0x49059802, 0x49059902, 0x49059a02, 0x49059b02, + 0x49059c02, 0x49059d02, 0x49059e02, 0x49059f02, 0x4905a002, 0x4905a102, 0x4905a202, 0x4905a302, + 0x4905a402, 0x4905a502, 0x4905a602, 0x4905a702, 0x4905a802, 0x4905a902, 0x4905aa02, 0x4905ab02, + 0x4905ac02, 0x4905ad02, 0x4905ae02, 0x4905af02, 0x4905b002, 0x4905b102, 0x4905b202, 0x4905b302, + 0x4905b402, 0x4905b502, 0x4905b602, 0x4905b702, 0x4905b802, 0x4905b902, 0x4905ba02, 0x4905bb02, + 0x4905bc02, 0x4905bd02, 0x4905be02, 0x4905bf02, 0x4905c002, 0x4905c102, 0x4905c202, 0x4905c302, + 0x4905c402, 0x4905c502, 0x4905c602, 0x4905c702, 0x4905c802, 0x4905c902, 0x4905ca02, 0x4905cb02, + 0x4905cc02, 0x4905cd02, 0x4905ce02, 0x4905cf02, 0x4905d002, 0x4905d102, 0x4905d202, 0x4905d302, + 0x4905d402, 0x4905d502, 0x4905d602, 0x4905d702, 0x4905d802, 0x4905d902, 0x4905da02, 0x4905db02, + 0x4905dc02, 0x4905dd02, 0x4905de02, 0x4905df02, 0x4905e002, 0x4905e102, 0x4905e202, 0x4905e302, + 0x4905e402, 0x4905e502, 0x4905e602, 0x4905e702, 0x4905e802, 0x4905e902, 0x4905ea02, 0x4905eb02, + 0x4905ec02, 0x4905ed02, 0x4905ee02, 0x4905ef02, 0x4905f002, 0x4905f102, 0x4905f202, 0x4905f302, + 0x4905f402, 0x4905f502, 0x4905f602, 0x4905f702, 0x4905f802, 0x4905f902, 0x4905fa02, 0x4905fb02, + 0x4905fc02, 0x4905fd02, 0x4905fe02, 0x4905ff02, 0x4a050202, 0x4a050302, 0x4a050402, 0x4a050502, + 0x4a050602, 0x4a050702, 0x4a050802, 0x4a050902, 0x4a050a02, 0x4a050b02, 0x4a050c02, 0x4a050d02, + 0x4a050e02, 0x4a050f02, 0x4a051002, 0x4a051102, 0x4a051202, 0x4a051302, 0x4a051402, 0x4a051502, + 0x4a051602, 0x4a051702, 0x4a051802, 0x4a051902, 0x4a051a02, 0x4a051b02, 0x4a051c02, 0x4a051d02, + 0x4a051e02, 0x4a051f02, 0x4a052002, 0x4a052102, 0x4a052202, 0x4a052302, 0x4a052402, 0x4a052502, + 0x4a052602, 0x4a052702, 0x4a052802, 0x4a052902, 0x4a052a02, 0x4a052b02, 0x4a052c02, 0x4a052d02, + 0x4a052e02, 0x4a052f02, 0x4a053002, 0x4a053102, 0x4a053202, 0x4a053302, 0x4a053402, 0x4a053502, + 0x4a053602, 0x4a053702, 0x4a053802, 0x4a053902, 0x4a053a02, 0x4a053b02, 0x4a053c02, 0x4a053d02, + 0x4a053e02, 0x4a053f02, 0x4a054002, 0x4a054102, 0x4a054202, 0x4a054302, 0x4a054402, 0x4a054502, + 0x4a054602, 0x4a054702, 0x4a054802, 0x4a054902, 0x4a054a02, 0x4a054b02, 0x4a054c02, 0x4a054d02, + 0x4a054e02, 0x4a054f02, 0x4a055002, 0x4a055102, 0x4a055202, 0x4a055302, 0x4a055402, 0x4a055502, + 0x4a055602, 0x4a055702, 0x4a055802, 0x4a055902, 0x4a055a02, 0x4a055b02, 0x4a055c02, 0x4a055d02, + 0x4a055e02, 0x4a055f02, 0x4a056002, 0x4a056102, 0x4a056202, 0x4a056302, 0x4a056402, 0x4a056502, + 0x4a056602, 0x4a056702, 0x4a056802, 0x4a056902, 0x4a056a02, 0x4a056b02, 0x4a056c02, 0x4a056d02, + 0x4a056e02, 0x4a056f02, 0x4a057002, 0x4a057102, 0x4a057202, 0x4a057302, 0x4a057402, 0x4a057502, + 0x4a057602, 0x4a057702, 0x4a057802, 0x4a057902, 0x4a057a02, 0x4a057b02, 0x4a057c02, 0x4a057d02, + 0x4a057e02, 0x4a057f02, 0x4a058002, 0x4a058102, 0x4a058202, 0x4a058302, 0x4a058402, 0x4a058502, + 0x4a058602, 0x4a058702, 0x4a058802, 0x4a058902, 0x4a058a02, 0x4a058b02, 0x4a058c02, 0x4a058d02, + 0x4a058e02, 0x4a058f02, 0x4a059002, 0x4a059102, 0x4a059202, 0x4a059302, 0x4a059402, 0x4a059502, + 0x4a059602, 0x4a059702, 0x4a059802, 0x4a059902, 0x4a059a02, 0x4a059b02, 0x4a059c02, 0x4a059d02, + 0x4a059e02, 0x4a059f02, 0x4a05a002, 0x4a05a102, 0x4a05a202, 0x4a05a302, 0x4a05a402, 0x4a05a502, + 0x4a05a602, 0x4a05a702, 0x4a05a802, 0x4a05a902, 0x4a05aa02, 0x4a05ab02, 0x4a05ac02, 0x4a05ad02, + 0x4a05ae02, 0x4a05af02, 0x4a05b002, 0x4a05b102, 0x4a05b202, 0x4a05b302, 0x4a05b402, 0x4a05b502, + 0x4a05b602, 0x4a05b702, 0x4a05b802, 0x4a05b902, 0x4a05ba02, 0x4a05bb02, 0x4a05bc02, 0x4a05bd02, + 0x4a05be02, 0x4a05bf02, 0x4a05c002, 0x4a05c102, 0x4a05c202, 0x4a05c302, 0x4a05c402, 0x4a05c502, + 0x4a05c602, 0x4a05c702, 0x4a05c802, 0x4a05c902, 0x4a05ca02, 0x4a05cb02, 0x4a05cc02, 0x4a05cd02, + 0x4a05ce02, 0x4a05cf02, 0x4a05d002, 0x4a05d102, 0x4a05d202, 0x4a05d302, 0x4a05d402, 0x4a05d502, + 0x4a05d602, 0x4a05d702, 0x4a05d802, 0x4a05d902, 0x4a05da02, 0x4a05db02, 0x4a05dc02, 0x4a05dd02, + 0x4a05de02, 0x4a05df02, 0x4a05e002, 0x4a05e102, 0x4a05e202, 0x4a05e302, 0x4a05e402, 0x4a05e502, + 0x4a05e602, 0x4a05e702, 0x4a05e802, 0x4a05e902, 0x4a05ea02, 0x4a05eb02, 0x4a05ec02, 0x4a05ed02, + 0x4a05ee02, 0x4a05ef02, 0x4a05f002, 0x4a05f102, 0x4a05f202, 0x4a05f302, 0x4a05f402, 0x4a05f502, + 0x4a05f602, 0x4a05f702, 0x4a05f802, 0x4a05f902, 0x4a05fa02, 0x4a05fb02, 0x4a05fc02, 0x4a05fd02, + 0x4a05fe02, 0x4a05ff02, 0x4b050202, 0x4b050302, 0x4b050402, 0x4b050502, 0x4b050602, 0x4b050702, + 0x4b050802, 0x4b050902, 0x4b050a02, 0x4b050b02, 0x4b050c02, 0x4b050d02, 0x4b050e02, 0x4b050f02, + 0x4b051002, 0x4b051102, 0x4b051202, 0x4b051302, 0x4b051402, 0x4b051502, 0x4b051602, 0x4b051702, + 0x4b051802, 0x4b051902, 0x4b051a02, 0x4b051b02, 0x4b051c02, 0x4b051d02, 0x4b051e02, 0x4b051f02, + 0x4b052002, 0x4b052102, 0x4b052202, 0x4b052302, 0x4b052402, 0x4b052502, 0x4b052602, 0x4b052702, + 0x4b052802, 0x4b052902, 0x4b052a02, 0x4b052b02, 0x4b052c02, 0x4b052d02, 0x4b052e02, 0x4b052f02, + 0x4b053002, 0x4b053102, 0x4b053202, 0x4b053302, 0x4b053402, 0x4b053502, 0x4b053602, 0x4b053702, + 0x4b053802, 0x4b053902, 0x4b053a02, 0x4b053b02, 0x4b053c02, 0x4b053d02, 0x4b053e02, 0x4b053f02, + 0x4b054002, 0x4b054102, 0x4b054202, 0x4b054302, 0x4b054402, 0x4b054502, 0x4b054602, 0x4b054702, + 0x4b054802, 0x4b054902, 0x4b054a02, 0x4b054b02, 0x4b054c02, 0x4b054d02, 0x4b054e02, 0x4b054f02, + 0x4b055002, 0x4b055102, 0x4b055202, 0x4b055302, 0x4b055402, 0x4b055502, 0x4b055602, 0x4b055702, + 0x4b055802, 0x4b055902, 0x4b055a02, 0x4b055b02, 0x4b055c02, 0x4b055d02, 0x4b055e02, 0x4b055f02, + 0x4b056002, 0x4b056102, 0x4b056202, 0x4b056302, 0x4b056402, 0x4b056502, 0x4b056602, 0x4b056702, + 0x4b056802, 0x4b056902, 0x4b056a02, 0x4b056b02, 0x4b056c02, 0x4b056d02, 0x4b056e02, 0x4b056f02, + 0x4b057002, 0x4b057102, 0x4b057202, 0x4b057302, 0x4b057402, 0x4b057502, 0x4b057602, 0x4b057702, + 0x4b057802, 0x4b057902, 0x4b057a02, 0x4b057b02, 0x4b057c02, 0x4b057d02, 0x4b057e02, 0x4b057f02, + 0x4b058002, 0x4b058102, 0x4b058202, 0x4b058302, 0x4b058402, 0x4b058502, 0x4b058602, 0x4b058702, + 0x4b058802, 0x4b058902, 0x4b058a02, 0x4b058b02, 0x4b058c02, 0x4b058d02, 0x4b058e02, 0x4b058f02, + 0x4b059002, 0x4b059102, 0x4b059202, 0x4b059302, 0x4b059402, 0x4b059502, 0x4b059602, 0x4b059702, + 0x4b059802, 0x4b059902, 0x4b059a02, 0x4b059b02, 0x4b059c02, 0x4b059d02, 0x4b059e02, 0x4b059f02, + 0x4b05a002, 0x4b05a102, 0x4b05a202, 0x4b05a302, 0x4b05a402, 0x4b05a502, 0x4b05a602, 0x4b05a702, + 0x4b05a802, 0x4b05a902, 0x4b05aa02, 0x4b05ab02, 0x4b05ac02, 0x4b05ad02, 0x4b05ae02, 0x4b05af02, + 0x4b05b002, 0x4b05b102, 0x4b05b202, 0x4b05b302, 0x4b05b402, 0x4b05b502, 0x4b05b602, 0x4b05b702, + 0x4b05b802, 0x4b05b902, 0x4b05ba02, 0x4b05bb02, 0x4b05bc02, 0x4b05bd02, 0x4b05be02, 0x4b05bf02, + 0x4b05c002, 0x4b05c102, 0x4b05c202, 0x4b05c302, 0x4b05c402, 0x4b05c502, 0x4b05c602, 0x4b05c702, + 0x4b05c802, 0x4b05c902, 0x4b05ca02, 0x4b05cb02, 0x4b05cc02, 0x4b05cd02, 0x4b05ce02, 0x4b05cf02, + 0x4b05d002, 0x4b05d102, 0x4b05d202, 0x4b05d302, 0x4b05d402, 0x4b05d502, 0x4b05d602, 0x4b05d702, + 0x4b05d802, 0x4b05d902, 0x4b05da02, 0x4b05db02, 0x4b05dc02, 0x4b05dd02, 0x4b05de02, 0x4b05df02, + 0x4b05e002, 0x4b05e102, 0x4b05e202, 0x4b05e302, 0x4b05e402, 0x4b05e502, 0x4b05e602, 0x4b05e702, + 0x4b05e802, 0x4b05e902, 0x4b05ea02, 0x4b05eb02, 0x4b05ec02, 0x4b05ed02, 0x4b05ee02, 0x4b05ef02, + 0x4b05f002, 0x4b05f102, 0x4b05f202, 0x4b05f302, 0x4b05f402, 0x4b05f502, 0x4b05f602, 0x4b05f702, + 0x4b05f802, 0x4b05f902, 0x4b05fa02, 0x4b05fb02, 0x4b05fc02, 0x4b05fd02, 0x4b05fe02, 0x4b05ff02, + 0x4c050202, 0x4c050302, 0x4c050402, 0x4c050502, 0x4c050602, 0x4c050702, 0x4c050802, 0x4c050902, + 0x4c050a02, 0x4c050b02, 0x4c050c02, 0x4c050d02, 0x4c050e02, 0x4c050f02, 0x4c051002, 0x4c051102, + 0x4c051202, 0x4c051302, 0x4c051402, 0x4c051502, 0x4c051602, 0x4c051702, 0x4c051802, 0x4c051902, + 0x4c051a02, 0x4c051b02, 0x4c051c02, 0x4c051d02, 0x4c051e02, 0x4c051f02, 0x4c052002, 0x4c052102, + 0x4c052202, 0x4c052302, 0x4c052402, 0x4c052502, 0x4c052602, 0x4c052702, 0x4c052802, 0x4c052902, + 0x4c052a02, 0x4c052b02, 0x4c052c02, 0x4c052d02, 0x4c052e02, 0x4c052f02, 0x4c053002, 0x4c053102, + 0x4c053202, 0x4c053302, 0x4c053402, 0x4c053502, 0x4c053602, 0x4c053702, 0x4c053802, 0x4c053902, + 0x4c053a02, 0x4c053b02, 0x4c053c02, 0x4c053d02, 0x4c053e02, 0x4c053f02, 0x4c054002, 0x4c054102, + 0x4c054202, 0x4c054302, 0x4c054402, 0x4c054502, 0x4c054602, 0x4c054702, 0x4c054802, 0x4c054902, + 0x4c054a02, 0x4c054b02, 0x4c054c02, 0x4c054d02, 0x4c054e02, 0x4c054f02, 0x4c055002, 0x4c055102, + 0x4c055202, 0x4c055302, 0x4c055402, 0x4c055502, 0x4c055602, 0x4c055702, 0x4c055802, 0x4c055902, + 0x4c055a02, 0x4c055b02, 0x4c055c02, 0x4c055d02, 0x4c055e02, 0x4c055f02, 0x4c056002, 0x4c056102, + 0x4c056202, 0x4c056302, 0x4c056402, 0x4c056502, 0x4c056602, 0x4c056702, 0x4c056802, 0x4c056902, + 0x4c056a02, 0x4c056b02, 0x4c056c02, 0x4c056d02, 0x4c056e02, 0x4c056f02, 0x4c057002, 0x4c057102, + 0x4c057202, 0x4c057302, 0x4c057402, 0x4c057502, 0x4c057602, 0x4c057702, 0x4c057802, 0x4c057902, + 0x4c057a02, 0x4c057b02, 0x4c057c02, 0x4c057d02, 0x4c057e02, 0x4c057f02, 0x4c058002, 0x4c058102, + 0x4c058202, 0x4c058302, 0x4c058402, 0x4c058502, 0x4c058602, 0x4c058702, 0x4c058802, 0x4c058902, + 0x4c058a02, 0x4c058b02, 0x4c058c02, 0x4c058d02, 0x4c058e02, 0x4c058f02, 0x4c059002, 0x4c059102, + 0x4c059202, 0x4c059302, 0x4c059402, 0x4c059502, 0x4c059602, 0x4c059702, 0x4c059802, 0x4c059902, + 0x4c059a02, 0x4c059b02, 0x4c059c02, 0x4c059d02, 0x4c059e02, 0x4c059f02, 0x4c05a002, 0x4c05a102, + 0x4c05a202, 0x4c05a302, 0x4c05a402, 0x4c05a502, 0x4c05a602, 0x4c05a702, 0x4c05a802, 0x4c05a902, + 0x4c05aa02, 0x4c05ab02, 0x4c05ac02, 0x4c05ad02, 0x4c05ae02, 0x4c05af02, 0x4c05b002, 0x4c05b102, + 0x4c05b202, 0x4c05b302, 0x4c05b402, 0x4c05b502, 0x4c05b602, 0x4c05b702, 0x4c05b802, 0x4c05b902, + 0x4c05ba02, 0x4c05bb02, 0x4c05bc02, 0x4c05bd02, 0x4c05be02, 0x4c05bf02, 0x4c05c002, 0x4c05c102, + 0x4c05c202, 0x4c05c302, 0x4c05c402, 0x4c05c502, 0x4c05c602, 0x4c05c702, 0x4c05c802, 0x4c05c902, + 0x4c05ca02, 0x4c05cb02, 0x4c05cc02, 0x4c05cd02, 0x4c05ce02, 0x4c05cf02, 0x4c05d002, 0x4c05d102, + 0x4c05d202, 0x4c05d302, 0x4c05d402, 0x4c05d502, 0x4c05d602, 0x4c05d702, 0x4c05d802, 0x4c05d902, + 0x4c05da02, 0x4c05db02, 0x4c05dc02, 0x4c05dd02, 0x4c05de02, 0x4c05df02, 0x4c05e002, 0x4c05e102, + 0x4c05e202, 0x4c05e302, 0x4c05e402, 0x4c05e502, 0x4c05e602, 0x4c05e702, 0x4c05e802, 0x4c05e902, + 0x4c05ea02, 0x4c05eb02, 0x4c05ec02, 0x4c05ed02, 0x4c05ee02, 0x4c05ef02, 0x4c05f002, 0x4c05f102, + 0x4c05f202, 0x4c05f302, 0x4c05f402, 0x4c05f502, 0x4c05f602, 0x4c05f702, 0x4c05f802, 0x4c05f902, + 0x4c05fa02, 0x4c05fb02, 0x4c05fc02, 0x4c05fd02, 0x4c05fe02, 0x4c05ff02, 0x4d050202, 0x4d050302, + 0x4d050402, 0x4d050502, 0x4d050602, 0x4d050702, 0x4d050802, 0x4d050902, 0x4d050a02, 0x4d050b02, + 0x4d050c02, 0x4d050d02, 0x4d050e02, 0x4d050f02, 0x4d051002, 0x4d051102, 0x4d051202, 0x4d051302, + 0x4d051402, 0x4d051502, 0x4d051602, 0x4d051702, 0x4d051802, 0x4d051902, 0x4d051a02, 0x4d051b02, + 0x4d051c02, 0x4d051d02, 0x4d051e02, 0x4d051f02, 0x4d052002, 0x4d052102, 0x4d052202, 0x4d052302, + 0x4d052402, 0x4d052502, 0x4d052602, 0x4d052702, 0x4d052802, 0x4d052902, 0x4d052a02, 0x4d052b02, + 0x4d052c02, 0x4d052d02, 0x4d052e02, 0x4d052f02, 0x4d053002, 0x4d053102, 0x4d053202, 0x4d053302, + 0x4d053402, 0x4d053502, 0x4d053602, 0x4d053702, 0x4d053802, 0x4d053902, 0x4d053a02, 0x4d053b02, + 0x4d053c02, 0x4d053d02, 0x4d053e02, 0x4d053f02, 0x4d054002, 0x4d054102, 0x4d054202, 0x4d054302, + 0x4d054402, 0x4d054502, 0x4d054602, 0x4d054702, 0x4d054802, 0x4d054902, 0x4d054a02, 0x4d054b02, + 0x4d054c02, 0x4d054d02, 0x4d054e02, 0x4d054f02, 0x4d055002, 0x4d055102, 0x4d055202, 0x4d055302, + 0x4d055402, 0x4d055502, 0x4d055602, 0x4d055702, 0x4d055802, 0x4d055902, 0x4d055a02, 0x4d055b02, + 0x4d055c02, 0x4d055d02, 0x4d055e02, 0x4d055f02, 0x4d056002, 0x4d056102, 0x4d056202, 0x4d056302, + 0x4d056402, 0x4d056502, 0x4d056602, 0x4d056702, 0x4d056802, 0x4d056902, 0x4d056a02, 0x4d056b02, + 0x4d056c02, 0x4d056d02, 0x4d056e02, 0x4d056f02, 0x4d057002, 0x4d057102, 0x4d057202, 0x4d057302, + 0x4d057402, 0x4d057502, 0x4d057602, 0x4d057702, 0x4d057802, 0x4d057902, 0x4d057a02, 0x4d057b02, + 0x4d057c02, 0x4d057d02, 0x4d057e02, 0x4d057f02, 0x4d058002, 0x4d058102, 0x4d058202, 0x4d058302, + 0x4d058402, 0x4d058502, 0x4d058602, 0x4d058702, 0x4d058802, 0x4d058902, 0x4d058a02, 0x4d058b02, + 0x4d058c02, 0x4d058d02, 0x4d058e02, 0x4d058f02, 0x4d059002, 0x4d059102, 0x4d059202, 0x4d059302, + 0x4d059402, 0x4d059502, 0x4d059602, 0x4d059702, 0x4d059802, 0x4d059902, 0x4d059a02, 0x4d059b02, + 0x4d059c02, 0x4d059d02, 0x4d059e02, 0x4d059f02, 0x4d05a002, 0x4d05a102, 0x4d05a202, 0x4d05a302, + 0x4d05a402, 0x4d05a502, 0x4d05a602, 0x4d05a702, 0x4d05a802, 0x4d05a902, 0x4d05aa02, 0x4d05ab02, + 0x4d05ac02, 0x4d05ad02, 0x4d05ae02, 0x4d05af02, 0x4d05b002, 0x4d05b102, 0x4d05b202, 0x4d05b302, + 0x4d05b402, 0x4d05b502, 0x4d05b602, 0x4d05b702, 0x4d05b802, 0x4d05b902, 0x4d05ba02, 0x4d05bb02, + 0x4d05bc02, 0x4d05bd02, 0x4d05be02, 0x4d05bf02, 0x4d05c002, 0x4d05c102, 0x4d05c202, 0x4d05c302, + 0x4d05c402, 0x4d05c502, 0x4d05c602, 0x4d05c702, 0x4d05c802, 0x4d05c902, 0x4d05ca02, 0x4d05cb02, + 0x4d05cc02, 0x4d05cd02, 0x4d05ce02, 0x4d05cf02, 0x4d05d002, 0x4d05d102, 0x4d05d202, 0x4d05d302, + 0x4d05d402, 0x4d05d502, 0x4d05d602, 0x4d05d702, 0x4d05d802, 0x4d05d902, 0x4d05da02, 0x4d05db02, + 0x4d05dc02, 0x4d05dd02, 0x4d05de02, 0x4d05df02, 0x4d05e002, 0x4d05e102, 0x4d05e202, 0x4d05e302, + 0x4d05e402, 0x4d05e502, 0x4d05e602, 0x4d05e702, 0x4d05e802, 0x4d05e902, 0x4d05ea02, 0x4d05eb02, + 0x4d05ec02, 0x4d05ed02, 0x4d05ee02, 0x4d05ef02, 0x4d05f002, 0x4d05f102, 0x4d05f202, 0x4d05f302, + 0x4d05f402, 0x4d05f502, 0x4d05f602, 0x4d05f702, 0x4d05f802, 0x4d05f902, 0x4d05fa02, 0x4d05fb02, + 0x4d05fc02, 0x4d05fd02, 0x4d05fe02, 0x4d05ff02, 0x4e050202, 0x4e050302, 0x4e050402, 0x4e050502, + 0x4e050602, 0x4e050702, 0x4e050802, 0x4e050902, 0x4e050a02, 0x4e050b02, 0x4e050c02, 0x4e050d02, + 0x4e050e02, 0x4e050f02, 0x4e051002, 0x4e051102, 0x4e051202, 0x4e051302, 0x4e051402, 0x4e051502, + 0x4e051602, 0x4e051702, 0x4e051802, 0x4e051902, 0x4e051a02, 0x4e051b02, 0x4e051c02, 0x4e051d02, + 0x4e051e02, 0x4e051f02, 0x4e052002, 0x4e052102, 0x4e052202, 0x4e052302, 0x4e052402, 0x4e052502, + 0x4e052602, 0x4e052702, 0x4e052802, 0x4e052902, 0x4e052a02, 0x4e052b02, 0x4e052c02, 0x4e052d02, + 0x4e052e02, 0x4e052f02, 0x4e053002, 0x4e053102, 0x4e053202, 0x4e053302, 0x4e053402, 0x4e053502, + 0x4e053602, 0x4e053702, 0x4e053802, 0x4e053902, 0x4e053a02, 0x4e053b02, 0x4e053c02, 0x4e053d02, + 0x4e053e02, 0x4e053f02, 0x4e054002, 0x4e054102, 0x4e054202, 0x4e054302, 0x4e054402, 0x4e054502, + 0x4e054602, 0x4e054702, 0x4e054802, 0x4e054902, 0x4e054a02, 0x4e054b02, 0x4e054c02, 0x4e054d02, + 0x4e054e02, 0x4e054f02, 0x4e055002, 0x4e055102, 0x4e055202, 0x4e055302, 0x4e055402, 0x4e055502, + 0x4e055602, 0x4e055702, 0x4e055802, 0x4e055902, 0x4e055a02, 0x4e055b02, 0x4e055c02, 0x4e055d02, + 0x4e055e02, 0x4e055f02, 0x4e056002, 0x4e056102, 0x4e056202, 0x4e056302, 0x4e056402, 0x4e056502, + 0x4e056602, 0x4e056702, 0x4e056802, 0x4e056902, 0x4e056a02, 0x4e056b02, 0x4e056c02, 0x4e056d02, + 0x4e056e02, 0x4e056f02, 0x4e057002, 0x4e057102, 0x4e057202, 0x4e057302, 0x4e057402, 0x4e057502, + 0x4e057602, 0x4e057702, 0x4e057802, 0x4e057902, 0x4e057a02, 0x4e057b02, 0x4e057c02, 0x4e057d02, + 0x4e057e02, 0x4e057f02, 0x4e058002, 0x4e058102, 0x4e058202, 0x4e058302, 0x4e058402, 0x4e058502, + 0x4e058602, 0x4e058702, 0x4e058802, 0x4e058902, 0x4e058a02, 0x4e058b02, 0x4e058c02, 0x4e058d02, + 0x4e058e02, 0x4e058f02, 0x4e059002, 0x4e059102, 0x4e059202, 0x4e059302, 0x4e059402, 0x4e059502, + 0x4e059602, 0x4e059702, 0x4e059802, 0x4e059902, 0x4e059a02, 0x4e059b02, 0x4e059c02, 0x4e059d02, + 0x4e059e02, 0x4e059f02, 0x4e05a002, 0x4e05a102, 0x4e05a202, 0x4e05a302, 0x4e05a402, 0x4e05a502, + 0x4e05a602, 0x4e05a702, 0x4e05a802, 0x4e05a902, 0x4e05aa02, 0x4e05ab02, 0x4e05ac02, 0x4e05ad02, + 0x4e05ae02, 0x4e05af02, 0x4e05b002, 0x4e05b102, 0x4e05b202, 0x4e05b302, 0x4e05b402, 0x4e05b502, + 0x4e05b602, 0x4e05b702, 0x4e05b802, 0x4e05b902, 0x4e05ba02, 0x4e05bb02, 0x4e05bc02, 0x4e05bd02, + 0x4e05be02, 0x4e05bf02, 0x4e05c002, 0x4e05c102, 0x4e05c202, 0x4e05c302, 0x4e05c402, 0x4e05c502, + 0x4e05c602, 0x4e05c702, 0x4e05c802, 0x4e05c902, 0x4e05ca02, 0x4e05cb02, 0x4e05cc02, 0x4e05cd02, + 0x4e05ce02, 0x4e05cf02, 0x4e05d002, 0x4e05d102, 0x4e05d202, 0x4e05d302, 0x4e05d402, 0x4e05d502, + 0x4e05d602, 0x4e05d702, 0x4e05d802, 0x4e05d902, 0x4e05da02, 0x4e05db02, 0x4e05dc02, 0x4e05dd02, + 0x4e05de02, 0x4e05df02, 0x4e05e002, 0x4e05e102, 0x4e05e202, 0x4e05e302, 0x4e05e402, 0x4e05e502, + 0x4e05e602, 0x4e05e702, 0x4e05e802, 0x4e05e902, 0x4e05ea02, 0x4e05eb02, 0x4e05ec02, 0x4e05ed02, + 0x4e05ee02, 0x4e05ef02, 0x4e05f002, 0x4e05f102, 0x4e05f202, 0x4e05f302, 0x4e05f402, 0x4e05f502, + 0x4e05f602, 0x4e05f702, 0x4e05f802, 0x4e05f902, 0x4e05fa02, 0x4e05fb02, 0x4e05fc02, 0x4e05fd02, + 0x4e05fe02, 0x4e05ff02, 0x4f050202, 0x4f050302, 0x4f050402, 0x4f050502, 0x4f050602, 0x4f050702, + 0x4f050802, 0x4f050902, 0x4f050a02, 0x4f050b02, 0x4f050c02, 0x4f050d02, 0x4f050e02, 0x4f050f02, + 0x4f051002, 0x4f051102, 0x4f051202, 0x4f051302, 0x4f051402, 0x4f051502, 0x4f051602, 0x4f051702, + 0x4f051802, 0x4f051902, 0x4f051a02, 0x4f051b02, 0x4f051c02, 0x4f051d02, 0x4f051e02, 0x4f051f02, + 0x4f052002, 0x4f052102, 0x4f052202, 0x4f052302, 0x4f052402, 0x4f052502, 0x4f052602, 0x4f052702, + 0x4f052802, 0x4f052902, 0x4f052a02, 0x4f052b02, 0x4f052c02, 0x4f052d02, 0x4f052e02, 0x4f052f02, + 0x4f053002, 0x4f053102, 0x4f053202, 0x4f053302, 0x4f053402, 0x4f053502, 0x4f053602, 0x4f053702, + 0x4f053802, 0x4f053902, 0x4f053a02, 0x4f053b02, 0x4f053c02, 0x4f053d02, 0x4f053e02, 0x4f053f02, + 0x4f054002, 0x4f054102, 0x4f054202, 0x4f054302, 0x4f054402, 0x4f054502, 0x4f054602, 0x4f054702, + 0x4f054802, 0x4f054902, 0x4f054a02, 0x4f054b02, 0x4f054c02, 0x4f054d02, 0x4f054e02, 0x4f054f02, + 0x4f055002, 0x4f055102, 0x4f055202, 0x4f055302, 0x4f055402, 0x4f055502, 0x4f055602, 0x4f055702, + 0x4f055802, 0x4f055902, 0x4f055a02, 0x4f055b02, 0x4f055c02, 0x4f055d02, 0x4f055e02, 0x4f055f02, + 0x4f056002, 0x4f056102, 0x4f056202, 0x4f056302, 0x4f056402, 0x4f056502, 0x4f056602, 0x4f056702, + 0x4f056802, 0x4f056902, 0x4f056a02, 0x4f056b02, 0x4f056c02, 0x4f056d02, 0x4f056e02, 0x4f056f02, + 0x4f057002, 0x4f057102, 0x4f057202, 0x4f057302, 0x4f057402, 0x4f057502, 0x4f057602, 0x4f057702, + 0x4f057802, 0x4f057902, 0x4f057a02, 0x4f057b02, 0x4f057c02, 0x4f057d02, 0x4f057e02, 0x4f057f02, + 0x4f058002, 0x4f058102, 0x4f058202, 0x4f058302, 0x4f058402, 0x4f058502, 0x4f058602, 0x4f058702, + 0x4f058802, 0x4f058902, 0x4f058a02, 0x4f058b02, 0x4f058c02, 0x4f058d02, 0x4f058e02, 0x4f058f02, + 0x4f059002, 0x4f059102, 0x4f059202, 0x4f059302, 0x4f059402, 0x4f059502, 0x4f059602, 0x4f059702, + 0x4f059802, 0x4f059902, 0x4f059a02, 0x4f059b02, 0x4f059c02, 0x4f059d02, 0x4f059e02, 0x4f059f02, + 0x4f05a002, 0x4f05a102, 0x4f05a202, 0x4f05a302, 0x4f05a402, 0x4f05a502, 0x4f05a602, 0x4f05a702, + 0x4f05a802, 0x4f05a902, 0x4f05aa02, 0x4f05ab02, 0x4f05ac02, 0x4f05ad02, 0x4f05ae02, 0x4f05af02, + 0x4f05b002, 0x4f05b102, 0x4f05b202, 0x4f05b302, 0x4f05b402, 0x4f05b502, 0x4f05b602, 0x4f05b702, + 0x4f05b802, 0x4f05b902, 0x4f05ba02, 0x4f05bb02, 0x4f05bc02, 0x4f05bd02, 0x4f05be02, 0x4f05bf02, + 0x4f05c002, 0x4f05c102, 0x4f05c202, 0x4f05c302, 0x4f05c402, 0x4f05c502, 0x4f05c602, 0x4f05c702, + 0x4f05c802, 0x4f05c902, 0x4f05ca02, 0x4f05cb02, 0x4f05cc02, 0x4f05cd02, 0x4f05ce02, 0x4f05cf02, + 0x4f05d002, 0x4f05d102, 0x4f05d202, 0x4f05d302, 0x4f05d402, 0x4f05d502, 0x4f05d602, 0x4f05d702, + 0x4f05d802, 0x4f05d902, 0x4f05da02, 0x4f05db02, 0x4f05dc02, 0x4f05dd02, 0x4f05de02, 0x4f05df02, + 0x4f05e002, 0x4f05e102, 0x4f05e202, 0x4f05e302, 0x4f05e402, 0x4f05e502, 0x4f05e602, 0x4f05e702, + 0x4f05e802, 0x4f05e902, 0x4f05ea02, 0x4f05eb02, 0x4f05ec02, 0x4f05ed02, 0x4f05ee02, 0x4f05ef02, + 0x4f05f002, 0x4f05f102, 0x4f05f202, 0x4f05f302, 0x4f05f402, 0x4f05f502, 0x4f05f602, 0x4f05f702, + 0x4f05f802, 0x4f05f902, 0x4f05fa02, 0x4f05fb02, 0x4f05fc02, 0x4f05fd02, 0x4f05fe02, 0x4f05ff02, + 0x50050202, 0x50050302, 0x50050402, 0x50050502, 0x50050602, 0x50050702, 0x50050802, 0x50050902, + 0x50050a02, 0x50050b02, 0x50050c02, 0x50050d02, 0x50050e02, 0x50050f02, 0x50051002, 0x50051102, + 0x50051202, 0x50051302, 0x50051402, 0x50051502, 0x50051602, 0x50051702, 0x50051802, 0x50051902, + 0x50051a02, 0x50051b02, 0x50051c02, 0x50051d02, 0x50051e02, 0x50051f02, 0x50052002, 0x50052102, + 0x50052202, 0x50052302, 0x50052402, 0x50052502, 0x50052602, 0x50052702, 0x50052802, 0x50052902, + 0x50052a02, 0x50052b02, 0x50052c02, 0x50052d02, 0x50052e02, 0x50052f02, 0x50053002, 0x50053102, + 0x50053202, 0x50053302, 0x50053402, 0x50053502, 0x50053602, 0x50053702, 0x50053802, 0x50053902, + 0x50053a02, 0x50053b02, 0x50053c02, 0x50053d02, 0x50053e02, 0x50053f02, 0x50054002, 0x50054102, + 0x50054202, 0x50054302, 0x50054402, 0x50054502, 0x50054602, 0x50054702, 0x50054802, 0x50054902, + 0x50054a02, 0x50054b02, 0x50054c02, 0x50054d02, 0x50054e02, 0x50054f02, 0x50055002, 0x50055102, + 0x50055202, 0x50055302, 0x50055402, 0x50055502, 0x50055602, 0x50055702, 0x50055802, 0x50055902, + 0x50055a02, 0x50055b02, 0x50055c02, 0x50055d02, 0x50055e02, 0x50055f02, 0x50056002, 0x50056102, + 0x50056202, 0x50056302, 0x50056402, 0x50056502, 0x50056602, 0x50056702, 0x50056802, 0x50056902, + 0x50056a02, 0x50056b02, 0x50056c02, 0x50056d02, 0x50056e02, 0x50056f02, 0x50057002, 0x50057102, + 0x50057202, 0x50057302, 0x50057402, 0x50057502, 0x50057602, 0x50057702, 0x50057802, 0x50057902, + 0x50057a02, 0x50057b02, 0x50057c02, 0x50057d02, 0x50057e02, 0x50057f02, 0x50058002, 0x50058102, + 0x50058202, 0x50058302, 0x50058402, 0x50058502, 0x50058602, 0x50058702, 0x50058802, 0x50058902, + 0x50058a02, 0x50058b02, 0x50058c02, 0x50058d02, 0x50058e02, 0x50058f02, 0x50059002, 0x50059102, + 0x50059202, 0x50059302, 0x50059402, 0x50059502, 0x50059602, 0x50059702, 0x50059802, 0x50059902, + 0x50059a02, 0x50059b02, 0x50059c02, 0x50059d02, 0x50059e02, 0x50059f02, 0x5005a002, 0x5005a102, + 0x5005a202, 0x5005a302, 0x5005a402, 0x5005a502, 0x5005a602, 0x5005a702, 0x5005a802, 0x5005a902, + 0x5005aa02, 0x5005ab02, 0x5005ac02, 0x5005ad02, 0x5005ae02, 0x5005af02, 0x5005b002, 0x5005b102, + 0x5005b202, 0x5005b302, 0x5005b402, 0x5005b502, 0x5005b602, 0x5005b702, 0x5005b802, 0x5005b902, + 0x5005ba02, 0x5005bb02, 0x5005bc02, 0x5005bd02, 0x5005be02, 0x5005bf02, 0x5005c002, 0x5005c102, + 0x5005c202, 0x5005c302, 0x5005c402, 0x5005c502, 0x5005c602, 0x5005c702, 0x5005c802, 0x5005c902, + 0x5005ca02, 0x5005cb02, 0x5005cc02, 0x5005cd02, 0x5005ce02, 0x5005cf02, 0x5005d002, 0x5005d102, + 0x5005d202, 0x5005d302, 0x5005d402, 0x5005d502, 0x5005d602, 0x5005d702, 0x5005d802, 0x5005d902, + 0x5005da02, 0x5005db02, 0x5005dc02, 0x5005dd02, 0x5005de02, 0x5005df02, 0x5005e002, 0x5005e102, + 0x5005e202, 0x5005e302, 0x5005e402, 0x5005e502, 0x5005e602, 0x5005e702, 0x5005e802, 0x5005e902, + 0x5005ea02, 0x5005eb02, 0x5005ec02, 0x5005ed02, 0x5005ee02, 0x5005ef02, 0x5005f002, 0x5005f102, + 0x5005f202, 0x5005f302, 0x5005f402, 0x5005f502, 0x5005f602, 0x5005f702, 0x5005f802, 0x5005f902, + 0x5005fa02, 0x5005fb02, 0x5005fc02, 0x5005fd02, 0x5005fe02, 0x5005ff02, 0x51050202, 0x51050302, + 0x51050402, 0x51050502, 0x51050602, 0x51050702, 0x51050802, 0x51050902, 0x51050a02, 0x51050b02, + 0x51050c02, 0x51050d02, 0x51050e02, 0x51050f02, 0x51051002, 0x51051102, 0x51051202, 0x51051302, + 0x51051402, 0x51051502, 0x51051602, 0x51051702, 0x51051802, 0x51051902, 0x51051a02, 0x51051b02, + 0x51051c02, 0x51051d02, 0x51051e02, 0x51051f02, 0x51052002, 0x51052102, 0x51052202, 0x51052302, + 0x51052402, 0x51052502, 0x51052602, 0x51052702, 0x51052802, 0x51052902, 0x51052a02, 0x51052b02, + 0x51052c02, 0x51052d02, 0x51052e02, 0x51052f02, 0x51053002, 0x51053102, 0x51053202, 0x51053302, + 0x51053402, 0x51053502, 0x51053602, 0x51053702, 0x51053802, 0x51053902, 0x51053a02, 0x51053b02, + 0x51053c02, 0x51053d02, 0x51053e02, 0x51053f02, 0x51054002, 0x51054102, 0x51054202, 0x51054302, + 0x51054402, 0x51054502, 0x51054602, 0x51054702, 0x51054802, 0x51054902, 0x51054a02, 0x51054b02, + 0x51054c02, 0x51054d02, 0x51054e02, 0x51054f02, 0x51055002, 0x51055102, 0x51055202, 0x51055302, + 0x51055402, 0x51055502, 0x51055602, 0x51055702, 0x51055802, 0x51055902, 0x51055a02, 0x51055b02, + 0x51055c02, 0x51055d02, 0x51055e02, 0x51055f02, 0x51056002, 0x51056102, 0x51056202, 0x51056302, + 0x51056402, 0x51056502, 0x51056602, 0x51056702, 0x51056802, 0x51056902, 0x51056a02, 0x51056b02, + 0x51056c02, 0x51056d02, 0x51056e02, 0x51056f02, 0x51057002, 0x51057102, 0x51057202, 0x51057302, + 0x51057402, 0x51057502, 0x51057602, 0x51057702, 0x51057802, 0x51057902, 0x51057a02, 0x51057b02, + 0x51057c02, 0x51057d02, 0x51057e02, 0x51057f02, 0x51058002, 0x51058102, 0x51058202, 0x51058302, + 0x51058402, 0x51058502, 0x51058602, 0x51058702, 0x51058802, 0x51058902, 0x51058a02, 0x51058b02, + 0x51058c02, 0x51058d02, 0x51058e02, 0x51058f02, 0x51059002, 0x51059102, 0x51059202, 0x51059302, + 0x51059402, 0x51059502, 0x51059602, 0x51059702, 0x51059802, 0x51059902, 0x51059a02, 0x51059b02, + 0x51059c02, 0x51059d02, 0x51059e02, 0x51059f02, 0x5105a002, 0x5105a102, 0x5105a202, 0x5105a302, + 0x5105a402, 0x5105a502, 0x5105a602, 0x5105a702, 0x5105a802, 0x5105a902, 0x5105aa02, 0x5105ab02, + 0x5105ac02, 0x5105ad02, 0x5105ae02, 0x5105af02, 0x5105b002, 0x5105b102, 0x5105b202, 0x5105b302, + 0x5105b402, 0x5105b502, 0x5105b602, 0x5105b702, 0x5105b802, 0x5105b902, 0x5105ba02, 0x5105bb02, + 0x5105bc02, 0x5105bd02, 0x5105be02, 0x5105bf02, 0x5105c002, 0x5105c102, 0x5105c202, 0x5105c302, + 0x5105c402, 0x5105c502, 0x5105c602, 0x5105c702, 0x5105c802, 0x5105c902, 0x5105ca02, 0x5105cb02, + 0x5105cc02, 0x5105cd02, 0x5105ce02, 0x5105cf02, 0x5105d002, 0x5105d102, 0x5105d202, 0x5105d302, + 0x5105d402, 0x5105d502, 0x5105d602, 0x5105d702, 0x5105d802, 0x5105d902, 0x5105da02, 0x5105db02, + 0x5105dc02, 0x5105dd02, 0x5105de02, 0x5105df02, 0x5105e002, 0x5105e102, 0x5105e202, 0x5105e302, + 0x5105e402, 0x5105e502, 0x5105e602, 0x5105e702, 0x5105e802, 0x5105e902, 0x5105ea02, 0x5105eb02, + 0x5105ec02, 0x5105ed02, 0x5105ee02, 0x5105ef02, 0x5105f002, 0x5105f102, 0x5105f202, 0x5105f302, + 0x5105f402, 0x5105f502, 0x5105f602, 0x5105f702, 0x5105f802, 0x5105f902, 0x5105fa02, 0x5105fb02, + 0x5105fc02, 0x5105fd02, 0x5105fe02, 0x5105ff02, 0x52050202, 0x52050302, 0x52050402, 0x52050502, + 0x52050602, 0x52050702, 0x52050802, 0x52050902, 0x52050a02, 0x52050b02, 0x52050c02, 0x52050d02, + 0x52050e02, 0x52050f02, 0x52051002, 0x52051102, 0x52051202, 0x52051302, 0x52051402, 0x52051502, + 0x52051602, 0x52051702, 0x52051802, 0x52051902, 0x52051a02, 0x52051b02, 0x52051c02, 0x52051d02, + 0x52051e02, 0x52051f02, 0x52052002, 0x52052102, 0x52052202, 0x52052302, 0x52052402, 0x52052502, + 0x52052602, 0x52052702, 0x52052802, 0x52052902, 0x52052a02, 0x52052b02, 0x52052c02, 0x52052d02, + 0x52052e02, 0x52052f02, 0x52053002, 0x52053102, 0x52053202, 0x52053302, 0x52053402, 0x52053502, + 0x52053602, 0x52053702, 0x52053802, 0x52053902, 0x52053a02, 0x52053b02, 0x52053c02, 0x52053d02, + 0x52053e02, 0x52053f02, 0x52054002, 0x52054102, 0x52054202, 0x52054302, 0x52054402, 0x52054502, + 0x52054602, 0x52054702, 0x52054802, 0x52054902, 0x52054a02, 0x52054b02, 0x52054c02, 0x52054d02, + 0x52054e02, 0x52054f02, 0x52055002, 0x52055102, 0x52055202, 0x52055302, 0x52055402, 0x52055502, + 0x52055602, 0x52055702, 0x52055802, 0x52055902, 0x52055a02, 0x52055b02, 0x52055c02, 0x52055d02, + 0x52055e02, 0x52055f02, 0x52056002, 0x52056102, 0x52056202, 0x52056302, 0x52056402, 0x52056502, + 0x52056602, 0x52056702, 0x52056802, 0x52056902, 0x52056a02, 0x52056b02, 0x52056c02, 0x52056d02, + 0x52056e02, 0x52056f02, 0x52057002, 0x52057102, 0x52057202, 0x52057302, 0x52057402, 0x52057502, + 0x52057602, 0x52057702, 0x52057802, 0x52057902, 0x52057a02, 0x52057b02, 0x52057c02, 0x52057d02, + 0x52057e02, 0x52057f02, 0x52058002, 0x52058102, 0x52058202, 0x52058302, 0x52058402, 0x52058502, + 0x52058602, 0x52058702, 0x52058802, 0x52058902, 0x52058a02, 0x52058b02, 0x52058c02, 0x52058d02, + 0x52058e02, 0x52058f02, 0x52059002, 0x52059102, 0x52059202, 0x52059302, 0x52059402, 0x52059502, + 0x52059602, 0x52059702, 0x52059802, 0x52059902, 0x52059a02, 0x52059b02, 0x52059c02, 0x52059d02, + 0x52059e02, 0x52059f02, 0x5205a002, 0x5205a102, 0x5205a202, 0x5205a302, 0x5205a402, 0x5205a502, + 0x5205a602, 0x5205a702, 0x5205a802, 0x5205a902, 0x5205aa02, 0x5205ab02, 0x5205ac02, 0x5205ad02, + 0x5205ae02, 0x5205af02, 0x5205b002, 0x5205b102, 0x5205b202, 0x5205b302, 0x5205b402, 0x5205b502, + 0x5205b602, 0x5205b702, 0x5205b802, 0x5205b902, 0x5205ba02, 0x5205bb02, 0x5205bc02, 0x5205bd02, + 0x5205be02, 0x5205bf02, 0x5205c002, 0x5205c102, 0x5205c202, 0x5205c302, 0x5205c402, 0x5205c502, + 0x5205c602, 0x5205c702, 0x5205c802, 0x5205c902, 0x5205ca02, 0x5205cb02, 0x5205cc02, 0x5205cd02, + 0x5205ce02, 0x5205cf02, 0x5205d002, 0x5205d102, 0x5205d202, 0x5205d302, 0x5205d402, 0x5205d502, + 0x5205d602, 0x5205d702, 0x5205d802, 0x5205d902, 0x5205da02, 0x5205db02, 0x5205dc02, 0x5205dd02, + 0x5205de02, 0x5205df02, 0x5205e002, 0x5205e102, 0x5205e202, 0x5205e302, 0x5205e402, 0x5205e502, + 0x5205e602, 0x5205e702, 0x5205e802, 0x5205e902, 0x5205ea02, 0x5205eb02, 0x5205ec02, 0x5205ed02, + 0x5205ee02, 0x5205ef02, 0x5205f002, 0x5205f102, 0x5205f202, 0x5205f302, 0x5205f402, 0x5205f502, + 0x5205f602, 0x5205f702, 0x5205f802, 0x5205f902, 0x5205fa02, 0x5205fb02, 0x5205fc02, 0x5205fd02, + 0x5205fe02, 0x5205ff02, 0x53050202, 0x53050302, 0x53050402, 0x53050502, 0x53050602, 0x53050702, + 0x53050802, 0x53050902, 0x53050a02, 0x53050b02, 0x53050c02, 0x53050d02, 0x53050e02, 0x53050f02, + 0x53051002, 0x53051102, 0x53051202, 0x53051302, 0x53051402, 0x53051502, 0x53051602, 0x53051702, + 0x53051802, 0x53051902, 0x53051a02, 0x53051b02, 0x53051c02, 0x53051d02, 0x53051e02, 0x53051f02, + 0x53052002, 0x53052102, 0x53052202, 0x53052302, 0x53052402, 0x53052502, 0x53052602, 0x53052702, + 0x53052802, 0x53052902, 0x53052a02, 0x53052b02, 0x53052c02, 0x53052d02, 0x53052e02, 0x53052f02, + 0x53053002, 0x53053102, 0x53053202, 0x53053302, 0x53053402, 0x53053502, 0x53053602, 0x53053702, + 0x53053802, 0x53053902, 0x53053a02, 0x53053b02, 0x53053c02, 0x53053d02, 0x53053e02, 0x53053f02, + 0x53054002, 0x53054102, 0x53054202, 0x53054302, 0x53054402, 0x53054502, 0x53054602, 0x53054702, + 0x53054802, 0x53054902, 0x53054a02, 0x53054b02, 0x53054c02, 0x53054d02, 0x53054e02, 0x53054f02, + 0x53055002, 0x53055102, 0x53055202, 0x53055302, 0x53055402, 0x53055502, 0x53055602, 0x53055702, + 0x53055802, 0x53055902, 0x53055a02, 0x53055b02, 0x53055c02, 0x53055d02, 0x53055e02, 0x53055f02, + 0x53056002, 0x53056102, 0x53056202, 0x53056302, 0x53056402, 0x53056502, 0x53056602, 0x53056702, + 0x53056802, 0x53056902, 0x53056a02, 0x53056b02, 0x53056c02, 0x53056d02, 0x53056e02, 0x53056f02, + 0x53057002, 0x53057102, 0x53057202, 0x53057302, 0x53057402, 0x53057502, 0x53057602, 0x53057702, + 0x53057802, 0x53057902, 0x53057a02, 0x53057b02, 0x53057c02, 0x53057d02, 0x53057e02, 0x53057f02, + 0x53058002, 0x53058102, 0x53058202, 0x53058302, 0x53058402, 0x53058502, 0x53058602, 0x53058702, + 0x53058802, 0x53058902, 0x53058a02, 0x53058b02, 0x53058c02, 0x53058d02, 0x53058e02, 0x53058f02, + 0x53059002, 0x53059102, 0x53059202, 0x53059302, 0x53059402, 0x53059502, 0x53059602, 0x53059702, + 0x53059802, 0x53059902, 0x53059a02, 0x53059b02, 0x53059c02, 0x53059d02, 0x53059e02, 0x53059f02, + 0x5305a002, 0x5305a102, 0x5305a202, 0x5305a302, 0x5305a402, 0x5305a502, 0x5305a602, 0x5305a702, + 0x5305a802, 0x5305a902, 0x5305aa02, 0x5305ab02, 0x5305ac02, 0x5305ad02, 0x5305ae02, 0x5305af02, + 0x5305b002, 0x5305b102, 0x5305b202, 0x5305b302, 0x5305b402, 0x5305b502, 0x5305b602, 0x5305b702, + 0x5305b802, 0x5305b902, 0x5305ba02, 0x5305bb02, 0x5305bc02, 0x5305bd02, 0x5305be02, 0x5305bf02, + 0x5305c002, 0x5305c102, 0x5305c202, 0x5305c302, 0x5305c402, 0x5305c502, 0x5305c602, 0x5305c702, + 0x5305c802, 0x5305c902, 0x5305ca02, 0x5305cb02, 0x5305cc02, 0x5305cd02, 0x5305ce02, 0x5305cf02, + 0x5305d002, 0x5305d102, 0x5305d202, 0x5305d302, 0x5305d402, 0x5305d502, 0x5305d602, 0x5305d702, + 0x5305d802, 0x5305d902, 0x5305da02, 0x5305db02, 0x5305dc02, 0x5305dd02, 0x5305de02, 0x5305df02, + 0x5305e002, 0x5305e102, 0x5305e202, 0x5305e302, 0x5305e402, 0x5305e502, 0x5305e602, 0x5305e702, + 0x5305e802, 0x5305e902, 0x5305ea02, 0x5305eb02, 0x5305ec02, 0x5305ed02, 0x5305ee02, 0x5305ef02, + 0x5305f002, 0x5305f102, 0x5305f202, 0x5305f302, 0x5305f402, 0x5305f502, 0x5305f602, 0x5305f702, + 0x5305f802, 0x5305f902, 0x5305fa02, 0x5305fb02, 0x5305fc02, 0x5305fd02, 0x5305fe02, 0x5305ff02, + 0x54050202, 0x54050302, 0x54050402, 0x54050502, 0x54050602, 0x54050702, 0x54050802, 0x54050902, + 0x54050a02, 0x54050b02, 0x54050c02, 0x54050d02, 0x54050e02, 0x54050f02, 0x54051002, 0x54051102, + 0x54051202, 0x54051302, 0x54051402, 0x54051502, 0x54051602, 0x54051702, 0x54051802, 0x54051902, + 0x54051a02, 0x54051b02, 0x54051c02, 0x54051d02, 0x54051e02, 0x54051f02, 0x54052002, 0x54052102, + 0x54052202, 0x54052302, 0x54052402, 0x54052502, 0x54052602, 0x54052702, 0x54052802, 0x54052902, + 0x54052a02, 0x54052b02, 0x54052c02, 0x54052d02, 0x54052e02, 0x54052f02, 0x54053002, 0x54053102, + 0x54053202, 0x54053302, 0x54053402, 0x54053502, 0x54053602, 0x54053702, 0x54053802, 0x54053902, + 0x54053a02, 0x54053b02, 0x54053c02, 0x54053d02, 0x54053e02, 0x54053f02, 0x54054002, 0x54054102, + 0x54054202, 0x54054302, 0x54054402, 0x54054502, 0x54054602, 0x54054702, 0x54054802, 0x54054902, + 0x54054a02, 0x54054b02, 0x54054c02, 0x54054d02, 0x54054e02, 0x54054f02, 0x54055002, 0x54055102, + 0x54055202, 0x54055302, 0x54055402, 0x54055502, 0x54055602, 0x54055702, 0x54055802, 0x54055902, + 0x54055a02, 0x54055b02, 0x54055c02, 0x54055d02, 0x54055e02, 0x54055f02, 0x54056002, 0x54056102, + 0x54056202, 0x54056302, 0x54056402, 0x54056502, 0x54056602, 0x54056702, 0x54056802, 0x54056902, + 0x54056a02, 0x54056b02, 0x54056c02, 0x54056d02, 0x54056e02, 0x54056f02, 0x54057002, 0x54057102, + 0x54057202, 0x54057302, 0x54057402, 0x54057502, 0x54057602, 0x54057702, 0x54057802, 0x54057902, + 0x54057a02, 0x54057b02, 0x54057c02, 0x54057d02, 0x54057e02, 0x54057f02, 0x54058002, 0x54058102, + 0x54058202, 0x54058302, 0x54058402, 0x54058502, 0x54058602, 0x54058702, 0x54058802, 0x54058902, + 0x54058a02, 0x54058b02, 0x54058c02, 0x54058d02, 0x54058e02, 0x54058f02, 0x54059002, 0x54059102, + 0x54059202, 0x54059302, 0x54059402, 0x54059502, 0x54059602, 0x54059702, 0x54059802, 0x54059902, + 0x54059a02, 0x54059b02, 0x54059c02, 0x54059d02, 0x54059e02, 0x54059f02, 0x5405a002, 0x5405a102, + 0x5405a202, 0x5405a302, 0x5405a402, 0x5405a502, 0x5405a602, 0x5405a702, 0x5405a802, 0x5405a902, + 0x5405aa02, 0x5405ab02, 0x5405ac02, 0x5405ad02, 0x5405ae02, 0x5405af02, 0x5405b002, 0x5405b102, + 0x5405b202, 0x5405b302, 0x5405b402, 0x5405b502, 0x5405b602, 0x5405b702, 0x5405b802, 0x5405b902, + 0x5405ba02, 0x5405bb02, 0x5405bc02, 0x5405bd02, 0x5405be02, 0x5405bf02, 0x5405c002, 0x5405c102, + 0x5405c202, 0x5405c302, 0x5405c402, 0x5405c502, 0x5405c602, 0x5405c702, 0x5405c802, 0x5405c902, + 0x5405ca02, 0x5405cb02, 0x5405cc02, 0x5405cd02, 0x5405ce02, 0x5405cf02, 0x5405d002, 0x5405d102, + 0x5405d202, 0x5405d302, 0x5405d402, 0x5405d502, 0x5405d602, 0x5405d702, 0x5405d802, 0x5405d902, + 0x5405da02, 0x5405db02, 0x5405dc02, 0x5405dd02, 0x5405de02, 0x5405df02, 0x5405e002, 0x5405e102, + 0x5405e202, 0x5405e302, 0x5405e402, 0x5405e502, 0x5405e602, 0x5405e702, 0x5405e802, 0x5405e902, + 0x5405ea02, 0x5405eb02, 0x5405ec02, 0x5405ed02, 0x5405ee02, 0x5405ef02, 0x5405f002, 0x5405f102, + 0x5405f202, 0x5405f302, 0x5405f402, 0x5405f502, 0x5405f602, 0x5405f702, 0x5405f802, 0x5405f902, + 0x5405fa02, 0x5405fb02, 0x5405fc02, 0x5405fd02, 0x5405fe02, 0x5405ff02, 0x55050202, 0x55050302, + 0x55050402, 0x55050502, 0x55050602, 0x55050702, 0x55050802, 0x55050902, 0x55050a02, 0x55050b02, + 0x55050c02, 0x55050d02, 0x55050e02, 0x55050f02, 0x55051002, 0x55051102, 0x55051202, 0x55051302, + 0x55051402, 0x55051502, 0x55051602, 0x55051702, 0x55051802, 0x55051902, 0x55051a02, 0x55051b02, + 0x55051c02, 0x55051d02, 0x55051e02, 0x55051f02, 0x55052002, 0x55052102, 0x55052202, 0x55052302, + 0x55052402, 0x55052502, 0x55052602, 0x55052702, 0x55052802, 0x55052902, 0x55052a02, 0x55052b02, + 0x55052c02, 0x55052d02, 0x55052e02, 0x55052f02, 0x55053002, 0x55053102, 0x55053202, 0x55053302, + 0x55053402, 0x55053502, 0x55053602, 0x55053702, 0x55053802, 0x55053902, 0x55053a02, 0x55053b02, + 0x55053c02, 0x55053d02, 0x55053e02, 0x55053f02, 0x55054002, 0x55054102, 0x55054202, 0x55054302, + 0x55054402, 0x55054502, 0x55054602, 0x55054702, 0x55054802, 0x55054902, 0x55054a02, 0x55054b02, + 0x55054c02, 0x55054d02, 0x55054e02, 0x55054f02, 0x55055002, 0x55055102, 0x55055202, 0x55055302, + 0x55055402, 0x55055502, 0x55055602, 0x55055702, 0x55055802, 0x55055902, 0x55055a02, 0x55055b02, + 0x55055c02, 0x55055d02, 0x55055e02, 0x55055f02, 0x55056002, 0x55056102, 0x55056202, 0x55056302, + 0x55056402, 0x55056502, 0x55056602, 0x55056702, 0x55056802, 0x55056902, 0x55056a02, 0x55056b02, + 0x55056c02, 0x55056d02, 0x55056e02, 0x55056f02, 0x55057002, 0x55057102, 0x55057202, 0x55057302, + 0x55057402, 0x55057502, 0x55057602, 0x55057702, 0x55057802, 0x55057902, 0x55057a02, 0x55057b02, + 0x55057c02, 0x55057d02, 0x55057e02, 0x55057f02, 0x55058002, 0x55058102, 0x55058202, 0x55058302, + 0x55058402, 0x55058502, 0x55058602, 0x55058702, 0x55058802, 0x55058902, 0x55058a02, 0x55058b02, + 0x55058c02, 0x55058d02, 0x55058e02, 0x55058f02, 0x55059002, 0x55059102, 0x55059202, 0x55059302, + 0x55059402, 0x55059502, 0x55059602, 0x55059702, 0x55059802, 0x55059902, 0x55059a02, 0x55059b02, + 0x55059c02, 0x55059d02, 0x55059e02, 0x55059f02, 0x5505a002, 0x5505a102, 0x5505a202, 0x5505a302, + 0x5505a402, 0x5505a502, 0x5505a602, 0x5505a702, 0x5505a802, 0x5505a902, 0x5505aa02, 0x5505ab02, + 0x5505ac02, 0x5505ad02, 0x5505ae02, 0x5505af02, 0x5505b002, 0x5505b102, 0x5505b202, 0x5505b302, + 0x5505b402, 0x5505b502, 0x5505b602, 0x5505b702, 0x5505b802, 0x5505b902, 0x5505ba02, 0x5505bb02, + 0x5505bc02, 0x5505bd02, 0x5505be02, 0x5505bf02, 0x5505c002, 0x5505c102, 0x5505c202, 0x5505c302, + 0x5505c402, 0x5505c502, 0x5505c602, 0x5505c702, 0x5505c802, 0x5505c902, 0x5505ca02, 0x5505cb02, + 0x5505cc02, 0x5505cd02, 0x5505ce02, 0x5505cf02, 0x5505d002, 0x5505d102, 0x5505d202, 0x5505d302, + 0x5505d402, 0x5505d502, 0x5505d602, 0x5505d702, 0x5505d802, 0x5505d902, 0x5505da02, 0x5505db02, + 0x5505dc02, 0x5505dd02, 0x5505de02, 0x5505df02, 0x5505e002, 0x5505e102, 0x5505e202, 0x5505e302, + 0x5505e402, 0x5505e502, 0x5505e602, 0x5505e702, 0x5505e802, 0x5505e902, 0x5505ea02, 0x5505eb02, + 0x5505ec02, 0x5505ed02, 0x5505ee02, 0x5505ef02, 0x5505f002, 0x5505f102, 0x5505f202, 0x5505f302, + 0x5505f402, 0x5505f502, 0x5505f602, 0x5505f702, 0x5505f802, 0x5505f902, 0x5505fa02, 0x5505fb02, + 0x5505fc02, 0x5505fd02, 0x5505fe02, 0x5505ff02, 0x56050202, 0x56050302, 0x56050402, 0x56050502, + 0x56050602, 0x56050702, 0x56050802, 0x56050902, 0x56050a02, 0x56050b02, 0x56050c02, 0x56050d02, + 0x56050e02, 0x56050f02, 0x56051002, 0x56051102, 0x56051202, 0x56051302, 0x56051402, 0x56051502, + 0x56051602, 0x56051702, 0x56051802, 0x56051902, 0x56051a02, 0x56051b02, 0x56051c02, 0x56051d02, + 0x56051e02, 0x56051f02, 0x56052002, 0x56052102, 0x56052202, 0x56052302, 0x56052402, 0x56052502, + 0x56052602, 0x56052702, 0x56052802, 0x56052902, 0x56052a02, 0x56052b02, 0x56052c02, 0x56052d02, + 0x56052e02, 0x56052f02, 0x56053002, 0x56053102, 0x56053202, 0x56053302, 0x56053402, 0x56053502, + 0x56053602, 0x56053702, 0x56053802, 0x56053902, 0x56053a02, 0x56053b02, 0x56053c02, 0x56053d02, + 0x56053e02, 0x56053f02, 0x56054002, 0x56054102, 0x56054202, 0x56054302, 0x56054402, 0x56054502, + 0x56054602, 0x56054702, 0x56054802, 0x56054902, 0x56054a02, 0x56054b02, 0x56054c02, 0x56054d02, + 0x56054e02, 0x56054f02, 0x56055002, 0x56055102, 0x56055202, 0x56055302, 0x56055402, 0x56055502, + 0x56055602, 0x56055702, 0x56055802, 0x56055902, 0x56055a02, 0x56055b02, 0x56055c02, 0x56055d02, + 0x56055e02, 0x56055f02, 0x56056002, 0x56056102, 0x56056202, 0x56056302, 0x56056402, 0x56056502, + 0x56056602, 0x56056702, 0x56056802, 0x56056902, 0x56056a02, 0x56056b02, 0x56056c02, 0x56056d02, + 0x56056e02, 0x56056f02, 0x56057002, 0x56057102, 0x56057202, 0x56057302, 0x56057402, 0x56057502, + 0x56057602, 0x56057702, 0x56057802, 0x56057902, 0x56057a02, 0x56057b02, 0x56057c02, 0x56057d02, + 0x56057e02, 0x56057f02, 0x56058002, 0x56058102, 0x56058202, 0x56058302, 0x56058402, 0x56058502, + 0x56058602, 0x56058702, 0x56058802, 0x56058902, 0x56058a02, 0x56058b02, 0x56058c02, 0x56058d02, + 0x56058e02, 0x56058f02, 0x56059002, 0x56059102, 0x56059202, 0x56059302, 0x56059402, 0x56059502, + 0x56059602, 0x56059702, 0x56059802, 0x56059902, 0x56059a02, 0x56059b02, 0x56059c02, 0x56059d02, + 0x56059e02, 0x56059f02, 0x5605a002, 0x5605a102, 0x5605a202, 0x5605a302, 0x5605a402, 0x5605a502, + 0x5605a602, 0x5605a702, 0x5605a802, 0x5605a902, 0x5605aa02, 0x5605ab02, 0x5605ac02, 0x5605ad02, + 0x5605ae02, 0x5605af02, 0x5605b002, 0x5605b102, 0x5605b202, 0x5605b302, 0x5605b402, 0x5605b502, + 0x5605b602, 0x5605b702, 0x5605b802, 0x5605b902, 0x5605ba02, 0x5605bb02, 0x5605bc02, 0x5605bd02, + 0x5605be02, 0x5605bf02, 0x5605c002, 0x5605c102, 0x5605c202, 0x5605c302, 0x5605c402, 0x5605c502, + 0x5605c602, 0x5605c702, 0x5605c802, 0x5605c902, 0x5605ca02, 0x5605cb02, 0x5605cc02, 0x5605cd02, + 0x5605ce02, 0x5605cf02, 0x5605d002, 0x5605d102, 0x5605d202, 0x5605d302, 0x5605d402, 0x5605d502, + 0x5605d602, 0x5605d702, 0x5605d802, 0x5605d902, 0x5605da02, 0x5605db02, 0x5605dc02, 0x5605dd02, + 0x5605de02, 0x5605df02, 0x5605e002, 0x5605e102, 0x5605e202, 0x5605e302, 0x5605e402, 0x5605e502, + 0x5605e602, 0x5605e702, 0x5605e802, 0x5605e902, 0x5605ea02, 0x5605eb02, 0x5605ec02, 0x5605ed02, + 0x5605ee02, 0x5605ef02, 0x5605f002, 0x5605f102, 0x5605f202, 0x5605f302, 0x5605f402, 0x5605f502, + 0x5605f602, 0x5605f702, 0x5605f802, 0x5605f902, 0x5605fa02, 0x5605fb02, 0x5605fc02, 0x5605fd02, + 0x5605fe02, 0x5605ff02, 0x57050202, 0x57050302, 0x57050402, 0x57050502, 0x57050602, 0x57050702, + 0x57050802, 0x57050902, 0x57050a02, 0x57050b02, 0x57050c02, 0x57050d02, 0x57050e02, 0x57050f02, + 0x57051002, 0x57051102, 0x57051202, 0x57051302, 0x57051402, 0x57051502, 0x57051602, 0x57051702, + 0x57051802, 0x57051902, 0x57051a02, 0x57051b02, 0x57051c02, 0x57051d02, 0x57051e02, 0x57051f02, + 0x57052002, 0x57052102, 0x57052202, 0x57052302, 0x57052402, 0x57052502, 0x57052602, 0x57052702, + 0x57052802, 0x57052902, 0x57052a02, 0x57052b02, 0x57052c02, 0x57052d02, 0x57052e02, 0x57052f02, + 0x57053002, 0x57053102, 0x57053202, 0x57053302, 0x57053402, 0x57053502, 0x57053602, 0x57053702, + 0x57053802, 0x57053902, 0x57053a02, 0x57053b02, 0x57053c02, 0x57053d02, 0x57053e02, 0x57053f02, + 0x57054002, 0x57054102, 0x57054202, 0x57054302, 0x57054402, 0x57054502, 0x57054602, 0x57054702, + 0x57054802, 0x57054902, 0x57054a02, 0x57054b02, 0x57054c02, 0x57054d02, 0x57054e02, 0x57054f02, + 0x57055002, 0x57055102, 0x57055202, 0x57055302, 0x57055402, 0x57055502, 0x57055602, 0x57055702, + 0x57055802, 0x57055902, 0x57055a02, 0x57055b02, 0x57055c02, 0x57055d02, 0x57055e02, 0x57055f02, + 0x57056002, 0x57056102, 0x57056202, 0x57056302, 0x57056402, 0x57056502, 0x57056602, 0x57056702, + 0x57056802, 0x57056902, 0x57056a02, 0x57056b02, 0x57056c02, 0x57056d02, 0x57056e02, 0x57056f02, + 0x57057002, 0x57057102, 0x57057202, 0x57057302, 0x57057402, 0x57057502, 0x57057602, 0x57057702, + 0x57057802, 0x57057902, 0x57057a02, 0x57057b02, 0x57057c02, 0x57057d02, 0x57057e02, 0x57057f02, + 0x57058002, 0x57058102, 0x57058202, 0x57058302, 0x57058402, 0x57058502, 0x57058602, 0x57058702, + 0x57058802, 0x57058902, 0x57058a02, 0x57058b02, 0x57058c02, 0x57058d02, 0x57058e02, 0x57058f02, + 0x57059002, 0x57059102, 0x57059202, 0x57059302, 0x57059402, 0x57059502, 0x57059602, 0x57059702, + 0x57059802, 0x57059902, 0x57059a02, 0x57059b02, 0x57059c02, 0x57059d02, 0x57059e02, 0x57059f02, + 0x5705a002, 0x5705a102, 0x5705a202, 0x5705a302, 0x5705a402, 0x5705a502, 0x5705a602, 0x5705a702, + 0x5705a802, 0x5705a902, 0x5705aa02, 0x5705ab02, 0x5705ac02, 0x5705ad02, 0x5705ae02, 0x5705af02, + 0x5705b002, 0x5705b102, 0x5705b202, 0x5705b302, 0x5705b402, 0x5705b502, 0x5705b602, 0x5705b702, + 0x5705b802, 0x5705b902, 0x5705ba02, 0x5705bb02, 0x5705bc02, 0x5705bd02, 0x5705be02, 0x5705bf02, + 0x5705c002, 0x5705c102, 0x5705c202, 0x5705c302, 0x5705c402, 0x5705c502, 0x5705c602, 0x5705c702, + 0x5705c802, 0x5705c902, 0x5705ca02, 0x5705cb02, 0x5705cc02, 0x5705cd02, 0x5705ce02, 0x5705cf02, + 0x5705d002, 0x5705d102, 0x5705d202, 0x5705d302, 0x5705d402, 0x5705d502, 0x5705d602, 0x5705d702, + 0x5705d802, 0x5705d902, 0x5705da02, 0x5705db02, 0x5705dc02, 0x5705dd02, 0x5705de02, 0x5705df02, + 0x5705e002, 0x5705e102, 0x5705e202, 0x5705e302, 0x5705e402, 0x5705e502, 0x5705e602, 0x5705e702, + 0x5705e802, 0x5705e902, 0x5705ea02, 0x5705eb02, 0x5705ec02, 0x5705ed02, 0x5705ee02, 0x5705ef02, + 0x5705f002, 0x5705f102, 0x5705f202, 0x5705f302, 0x5705f402, 0x5705f502, 0x5705f602, 0x5705f702, + 0x5705f802, 0x5705f902, 0x5705fa02, 0x5705fb02, 0x5705fc02, 0x5705fd02, 0x5705fe02, 0x5705ff02, + 0x58050202, 0x58050302, 0x58050402, 0x58050502, 0x58050602, 0x58050702, 0x58050802, 0x58050902, + 0x58050a02, 0x58050b02, 0x58050c02, 0x58050d02, 0x58050e02, 0x58050f02, 0x58051002, 0x58051102, + 0x58051202, 0x58051302, 0x58051402, 0x58051502, 0x58051602, 0x58051702, 0x58051802, 0x58051902, + 0x58051a02, 0x58051b02, 0x58051c02, 0x58051d02, 0x58051e02, 0x58051f02, 0x58052002, 0x58052102, + 0x58052202, 0x58052302, 0x58052402, 0x58052502, 0x58052602, 0x58052702, 0x58052802, 0x58052902, + 0x58052a02, 0x58052b02, 0x58052c02, 0x58052d02, 0x58052e02, 0x58052f02, 0x58053002, 0x58053102, + 0x58053202, 0x58053302, 0x58053402, 0x58053502, 0x58053602, 0x58053702, 0x58053802, 0x58053902, + 0x58053a02, 0x58053b02, 0x58053c02, 0x58053d02, 0x58053e02, 0x58053f02, 0x58054002, 0x58054102, + 0x58054202, 0x58054302, 0x58054402, 0x58054502, 0x58054602, 0x58054702, 0x58054802, 0x58054902, + 0x58054a02, 0x58054b02, 0x58054c02, 0x58054d02, 0x58054e02, 0x58054f02, 0x58055002, 0x58055102, + 0x58055202, 0x58055302, 0x58055402, 0x58055502, 0x58055602, 0x58055702, 0x58055802, 0x58055902, + 0x58055a02, 0x58055b02, 0x58055c02, 0x58055d02, 0x58055e02, 0x58055f02, 0x58056002, 0x58056102, + 0x58056202, 0x58056302, 0x58056402, 0x58056502, 0x58056602, 0x58056702, 0x58056802, 0x58056902, + 0x58056a02, 0x58056b02, 0x58056c02, 0x58056d02, 0x58056e02, 0x58056f02, 0x58057002, 0x58057102, + 0x58057202, 0x58057302, 0x58057402, 0x58057502, 0x58057602, 0x58057702, 0x58057802, 0x58057902, + 0x58057a02, 0x58057b02, 0x58057c02, 0x58057d02, 0x58057e02, 0x58057f02, 0x58058002, 0x58058102, + 0x58058202, 0x58058302, 0x58058402, 0x58058502, 0x58058602, 0x58058702, 0x58058802, 0x58058902, + 0x58058a02, 0x58058b02, 0x58058c02, 0x58058d02, 0x58058e02, 0x58058f02, 0x58059002, 0x58059102, + 0x58059202, 0x58059302, 0x58059402, 0x58059502, 0x58059602, 0x58059702, 0x58059802, 0x58059902, + 0x58059a02, 0x58059b02, 0x58059c02, 0x58059d02, 0x58059e02, 0x58059f02, 0x5805a002, 0x5805a102, + 0x5805a202, 0x5805a302, 0x5805a402, 0x5805a502, 0x5805a602, 0x5805a702, 0x5805a802, 0x5805a902, + 0x5805aa02, 0x5805ab02, 0x5805ac02, 0x5805ad02, 0x5805ae02, 0x5805af02, 0x5805b002, 0x5805b102, + 0x5805b202, 0x5805b302, 0x5805b402, 0x5805b502, 0x5805b602, 0x5805b702, 0x5805b802, 0x5805b902, + 0x5805ba02, 0x5805bb02, 0x5805bc02, 0x5805bd02, 0x5805be02, 0x5805bf02, 0x5805c002, 0x5805c102, + 0x5805c202, 0x5805c302, 0x5805c402, 0x5805c502, 0x5805c602, 0x5805c702, 0x5805c802, 0x5805c902, + 0x5805ca02, 0x5805cb02, 0x5805cc02, 0x5805cd02, 0x5805ce02, 0x5805cf02, 0x5805d002, 0x5805d102, + 0x5805d202, 0x5805d302, 0x5805d402, 0x5805d502, 0x5805d602, 0x5805d702, 0x5805d802, 0x5805d902, + 0x5805da02, 0x5805db02, 0x5805dc02, 0x5805dd02, 0x5805de02, 0x5805df02, 0x5805e002, 0x5805e102, + 0x5805e202, 0x5805e302, 0x5805e402, 0x5805e502, 0x5805e602, 0x5805e702, 0x5805e802, 0x5805e902, + 0x5805ea02, 0x5805eb02, 0x5805ec02, 0x5805ed02, 0x5805ee02, 0x5805ef02, 0x5805f002, 0x5805f102, + 0x5805f202, 0x5805f302, 0x5805f402, 0x5805f502, 0x5805f602, 0x5805f702, 0x5805f802, 0x5805f902, + 0x5805fa02, 0x5805fb02, 0x5805fc02, 0x5805fd02, 0x5805fe02, 0x5805ff02, 0x59050202, 0x59050302, + 0x59050402, 0x59050502, 0x59050602, 0x59050702, 0x59050802, 0x59050902, 0x59050a02, 0x59050b02, + 0x59050c02, 0x59050d02, 0x59050e02, 0x59050f02, 0x59051002, 0x59051102, 0x59051202, 0x59051302, + 0x59051402, 0x59051502, 0x59051602, 0x59051702, 0x59051802, 0x59051902, 0x59051a02, 0x59051b02, + 0x59051c02, 0x59051d02, 0x59051e02, 0x59051f02, 0x59052002, 0x59052102, 0x59052202, 0x59052302, + 0x59052402, 0x59052502, 0x59052602, 0x59052702, 0x59052802, 0x59052902, 0x59052a02, 0x59052b02, + 0x59052c02, 0x59052d02, 0x59052e02, 0x59052f02, 0x59053002, 0x59053102, 0x59053202, 0x59053302, + 0x59053402, 0x59053502, 0x59053602, 0x59053702, 0x59053802, 0x59053902, 0x59053a02, 0x59053b02, + 0x59053c02, 0x59053d02, 0x59053e02, 0x59053f02, 0x59054002, 0x59054102, 0x59054202, 0x59054302, + 0x59054402, 0x59054502, 0x59054602, 0x59054702, 0x59054802, 0x59054902, 0x59054a02, 0x59054b02, + 0x59054c02, 0x59054d02, 0x59054e02, 0x59054f02, 0x59055002, 0x59055102, 0x59055202, 0x59055302, + 0x59055402, 0x59055502, 0x59055602, 0x59055702, 0x59055802, 0x59055902, 0x59055a02, 0x59055b02, + 0x59055c02, 0x59055d02, 0x59055e02, 0x59055f02, 0x59056002, 0x59056102, 0x59056202, 0x59056302, + 0x59056402, 0x59056502, 0x59056602, 0x59056702, 0x59056802, 0x59056902, 0x59056a02, 0x59056b02, + 0x59056c02, 0x59056d02, 0x59056e02, 0x59056f02, 0x59057002, 0x59057102, 0x59057202, 0x59057302, + 0x59057402, 0x59057502, 0x59057602, 0x59057702, 0x59057802, 0x59057902, 0x59057a02, 0x59057b02, + 0x59057c02, 0x59057d02, 0x59057e02, 0x59057f02, 0x59058002, 0x59058102, 0x59058202, 0x59058302, + 0x59058402, 0x59058502, 0x59058602, 0x59058702, 0x59058802, 0x59058902, 0x59058a02, 0x59058b02, + 0x59058c02, 0x59058d02, 0x59058e02, 0x59058f02, 0x59059002, 0x59059102, 0x59059202, 0x59059302, + 0x59059402, 0x59059502, 0x59059602, 0x59059702, 0x59059802, 0x59059902, 0x59059a02, 0x59059b02, + 0x59059c02, 0x59059d02, 0x59059e02, 0x59059f02, 0x5905a002, 0x5905a102, 0x5905a202, 0x5905a302, + 0x5905a402, 0x5905a502, 0x5905a602, 0x5905a702, 0x5905a802, 0x5905a902, 0x5905aa02, 0x5905ab02, + 0x5905ac02, 0x5905ad02, 0x5905ae02, 0x5905af02, 0x5905b002, 0x5905b102, 0x5905b202, 0x5905b302, + 0x5905b402, 0x5905b502, 0x5905b602, 0x5905b702, 0x5905b802, 0x5905b902, 0x5905ba02, 0x5905bb02, + 0x5905bc02, 0x5905bd02, 0x5905be02, 0x5905bf02, 0x5905c002, 0x5905c102, 0x5905c202, 0x5905c302, + 0x5905c402, 0x5905c502, 0x5905c602, 0x5905c702, 0x5905c802, 0x5905c902, 0x5905ca02, 0x5905cb02, + 0x5905cc02, 0x5905cd02, 0x5905ce02, 0x5905cf02, 0x5905d002, 0x5905d102, 0x5905d202, 0x5905d302, + 0x5905d402, 0x5905d502, 0x5905d602, 0x5905d702, 0x5905d802, 0x5905d902, 0x5905da02, 0x5905db02, + 0x5905dc02, 0x5905dd02, 0x5905de02, 0x5905df02, 0x5905e002, 0x5905e102, 0x5905e202, 0x5905e302, + 0x5905e402, 0x5905e502, 0x5905e602, 0x5905e702, 0x5905e802, 0x5905e902, 0x5905ea02, 0x5905eb02, + 0x5905ec02, 0x5905ed02, 0x5905ee02, 0x5905ef02, 0x5905f002, 0x5905f102, 0x5905f202, 0x5905f302, + 0x5905f402, 0x5905f502, 0x5905f602, 0x5905f702, 0x5905f802, 0x5905f902, 0x5905fa02, 0x5905fb02, + 0x5905fc02, 0x5905fd02, 0x5905fe02, 0x5905ff02, 0x5a050202, 0x5a050302, 0x5a050402, 0x5a050502, + 0x5a050602, 0x5a050702, 0x5a050802, 0x5a050902, 0x5a050a02, 0x5a050b02, 0x5a050c02, 0x5a050d02, + 0x5a050e02, 0x5a050f02, 0x5a051002, 0x5a051102, 0x5a051202, 0x5a051302, 0x5a051402, 0x5a051502, + 0x5a051602, 0x5a051702, 0x5a051802, 0x5a051902, 0x5a051a02, 0x5a051b02, 0x5a051c02, 0x5a051d02, + 0x5a051e02, 0x5a051f02, 0x5a052002, 0x5a052102, 0x5a052202, 0x5a052302, 0x5a052402, 0x5a052502, + 0x5a052602, 0x5a052702, 0x5a052802, 0x5a052902, 0x5a052a02, 0x5a052b02, 0x5a052c02, 0x5a052d02, + 0x5a052e02, 0x5a052f02, 0x5a053002, 0x5a053102, 0x5a053202, 0x5a053302, 0x5a053402, 0x5a053502, + 0x5a053602, 0x5a053702, 0x5a053802, 0x5a053902, 0x5a053a02, 0x5a053b02, 0x5a053c02, 0x5a053d02, + 0x5a053e02, 0x5a053f02, 0x5a054002, 0x5a054102, 0x5a054202, 0x5a054302, 0x5a054402, 0x5a054502, + 0x5a054602, 0x5a054702, 0x5a054802, 0x5a054902, 0x5a054a02, 0x5a054b02, 0x5a054c02, 0x5a054d02, + 0x5a054e02, 0x5a054f02, 0x5a055002, 0x5a055102, 0x5a055202, 0x5a055302, 0x5a055402, 0x5a055502, + 0x5a055602, 0x5a055702, 0x5a055802, 0x5a055902, 0x5a055a02, 0x5a055b02, 0x5a055c02, 0x5a055d02, + 0x5a055e02, 0x5a055f02, 0x5a056002, 0x5a056102, 0x5a056202, 0x5a056302, 0x5a056402, 0x5a056502, + 0x5a056602, 0x5a056702, 0x5a056802, 0x5a056902, 0x5a056a02, 0x5a056b02, 0x5a056c02, 0x5a056d02, + 0x5a056e02, 0x5a056f02, 0x5a057002, 0x5a057102, 0x5a057202, 0x5a057302, 0x5a057402, 0x5a057502, + 0x5a057602, 0x5a057702, 0x5a057802, 0x5a057902, 0x5a057a02, 0x5a057b02, 0x5a057c02, 0x5a057d02, + 0x5a057e02, 0x5a057f02, 0x5a058002, 0x5a058102, 0x5a058202, 0x5a058302, 0x5a058402, 0x5a058502, + 0x5a058602, 0x5a058702, 0x5a058802, 0x5a058902, 0x5a058a02, 0x5a058b02, 0x5a058c02, 0x5a058d02, + 0x5a058e02, 0x5a058f02, 0x5a059002, 0x5a059102, 0x5a059202, 0x5a059302, 0x5a059402, 0x5a059502, + 0x5a059602, 0x5a059702, 0x5a059802, 0x5a059902, 0x5a059a02, 0x5a059b02, 0x5a059c02, 0x5a059d02, + 0x5a059e02, 0x5a059f02, 0x5a05a002, 0x5a05a102, 0x5a05a202, 0x5a05a302, 0x5a05a402, 0x5a05a502, + 0x5a05a602, 0x5a05a702, 0x5a05a802, 0x5a05a902, 0x5a05aa02, 0x5a05ab02, 0x5a05ac02, 0x5a05ad02, + 0x5a05ae02, 0x5a05af02, 0x5a05b002, 0x5a05b102, 0x5a05b202, 0x5a05b302, 0x5a05b402, 0x5a05b502, + 0x5a05b602, 0x5a05b702, 0x5a05b802, 0x5a05b902, 0x5a05ba02, 0x5a05bb02, 0x5a05bc02, 0x5a05bd02, + 0x5a05be02, 0x5a05bf02, 0x5a05c002, 0x5a05c102, 0x5a05c202, 0x5a05c302, 0x5a05c402, 0x5a05c502, + 0x5a05c602, 0x5a05c702, 0x5a05c802, 0x5a05c902, 0x5a05ca02, 0x5a05cb02, 0x5a05cc02, 0x5a05cd02, + 0x5a05ce02, 0x5a05cf02, 0x5a05d002, 0x5a05d102, 0x5a05d202, 0x5a05d302, 0x5a05d402, 0x5a05d502, + 0x5a05d602, 0x5a05d702, 0x5a05d802, 0x5a05d902, 0x5a05da02, 0x5a05db02, 0x5a05dc02, 0x5a05dd02, + 0x5a05de02, 0x5a05df02, 0x5a05e002, 0x5a05e102, 0x5a05e202, 0x5a05e302, 0x5a05e402, 0x5a05e502, + 0x5a05e602, 0x5a05e702, 0x5a05e802, 0x5a05e902, 0x5a05ea02, 0x5a05eb02, 0x5a05ec02, 0x5a05ed02, + 0x5a05ee02, 0x5a05ef02, 0x5a05f002, 0x5a05f102, 0x5a05f202, 0x5a05f302, 0x5a05f402, 0x5a05f502, + 0x5a05f602, 0x5a05f702, 0x5a05f802, 0x5a05f902, 0x5a05fa02, 0x5a05fb02, 0x5a05fc02, 0x5a05fd02, + 0x5a05fe02, 0x5a05ff02, 0x5b050202, 0x5b050302, 0x5b050402, 0x5b050502, 0x5b050602, 0x5b050702, + 0x5b050802, 0x5b050902, 0x5b050a02, 0x5b050b02, 0x5b050c02, 0x5b050d02, 0x5b050e02, 0x5b050f02, + 0x5b051002, 0x5b051102, 0x5b051202, 0x5b051302, 0x5b051402, 0x5b051502, 0x5b051602, 0x5b051702, + 0x5b051802, 0x5b051902, 0x5b051a02, 0x5b051b02, 0x5b051c02, 0x5b051d02, 0x5b051e02, 0x5b051f02, + 0x5b052002, 0x5b052102, 0x5b052202, 0x5b052302, 0x5b052402, 0x5b052502, 0x5b052602, 0x5b052702, + 0x5b052802, 0x5b052902, 0x5b052a02, 0x5b052b02, 0x5b052c02, 0x5b052d02, 0x5b052e02, 0x5b052f02, + 0x5b053002, 0x5b053102, 0x5b053202, 0x5b053302, 0x5b053402, 0x5b053502, 0x5b053602, 0x5b053702, + 0x5b053802, 0x5b053902, 0x5b053a02, 0x5b053b02, 0x5b053c02, 0x5b053d02, 0x5b053e02, 0x5b053f02, + 0x5b054002, 0x5b054102, 0x5b054202, 0x5b054302, 0x5b054402, 0x5b054502, 0x5b054602, 0x5b054702, + 0x5b054802, 0x5b054902, 0x5b054a02, 0x5b054b02, 0x5b054c02, 0x5b054d02, 0x5b054e02, 0x5b054f02, + 0x5b055002, 0x5b055102, 0x5b055202, 0x5b055302, 0x5b055402, 0x5b055502, 0x5b055602, 0x5b055702, + 0x5b055802, 0x5b055902, 0x5b055a02, 0x5b055b02, 0x5b055c02, 0x5b055d02, 0x5b055e02, 0x5b055f02, + 0x5b056002, 0x5b056102, 0x5b056202, 0x5b056302, 0x5b056402, 0x5b056502, 0x5b056602, 0x5b056702, + 0x5b056802, 0x5b056902, 0x5b056a02, 0x5b056b02, 0x5b056c02, 0x5b056d02, 0x5b056e02, 0x5b056f02, + 0x5b057002, 0x5b057102, 0x5b057202, 0x5b057302, 0x5b057402, 0x5b057502, 0x5b057602, 0x5b057702, + 0x5b057802, 0x5b057902, 0x5b057a02, 0x5b057b02, 0x5b057c02, 0x5b057d02, 0x5b057e02, 0x5b057f02, + 0x5b058002, 0x5b058102, 0x5b058202, 0x5b058302, 0x5b058402, 0x5b058502, 0x5b058602, 0x5b058702, + 0x5b058802, 0x5b058902, 0x5b058a02, 0x5b058b02, 0x5b058c02, 0x5b058d02, 0x5b058e02, 0x5b058f02, + 0x5b059002, 0x5b059102, 0x5b059202, 0x5b059302, 0x5b059402, 0x5b059502, 0x5b059602, 0x5b059702, + 0x5b059802, 0x5b059902, 0x5b059a02, 0x5b059b02, 0x5b059c02, 0x5b059d02, 0x5b059e02, 0x5b059f02, + 0x5b05a002, 0x5b05a102, 0x5b05a202, 0x5b05a302, 0x5b05a402, 0x5b05a502, 0x5b05a602, 0x5b05a702, + 0x5b05a802, 0x5b05a902, 0x5b05aa02, 0x5b05ab02, 0x5b05ac02, 0x5b05ad02, 0x5b05ae02, 0x5b05af02, + 0x5b05b002, 0x5b05b102, 0x5b05b202, 0x5b05b302, 0x5b05b402, 0x5b05b502, 0x5b05b602, 0x5b05b702, + 0x5b05b802, 0x5b05b902, 0x5b05ba02, 0x5b05bb02, 0x5b05bc02, 0x5b05bd02, 0x5b05be02, 0x5b05bf02, + 0x5b05c002, 0x5b05c102, 0x5b05c202, 0x5b05c302, 0x5b05c402, 0x5b05c502, 0x5b05c602, 0x5b05c702, + 0x5b05c802, 0x5b05c902, 0x5b05ca02, 0x5b05cb02, 0x5b05cc02, 0x5b05cd02, 0x5b05ce02, 0x5b05cf02, + 0x5b05d002, 0x5b05d102, 0x5b05d202, 0x5b05d302, 0x5b05d402, 0x5b05d502, 0x5b05d602, 0x5b05d702, + 0x5b05d802, 0x5b05d902, 0x5b05da02, 0x5b05db02, 0x5b05dc02, 0x5b05dd02, 0x5b05de02, 0x5b05df02, + 0x5b05e002, 0x5b05e102, 0x5b05e202, 0x5b05e302, 0x5b05e402, 0x5b05e502, 0x5b05e602, 0x5b05e702, + 0x5b05e802, 0x5b05e902, 0x5b05ea02, 0x5b05eb02, 0x5b05ec02, 0x5b05ed02, 0x5b05ee02, 0x5b05ef02, + 0x5b05f002, 0x5b05f102, 0x5b05f202, 0x5b05f302, 0x5b05f402, 0x5b05f502, 0x5b05f602, 0x5b05f702, + 0x5b05f802, 0x5b05f902, 0x5b05fa02, 0x5b05fb02, 0x5b05fc02, 0x5b05fd02, 0x5b05fe02, 0x5b05ff02, + 0x5c050202, 0x5c050302, 0x5c050402, 0x5c050502, 0x5c050602, 0x5c050702, 0x5c050802, 0x5c050902, + 0x5c050a02, 0x5c050b02, 0x5c050c02, 0x5c050d02, 0x5c050e02, 0x5c050f02, 0x5c051002, 0x5c051102, + 0x5c051202, 0x5c051302, 0x5c051402, 0x5c051502, 0x5c051602, 0x5c051702, 0x5c051802, 0x5c051902, + 0x5c051a02, 0x5c051b02, 0x5c051c02, 0x5c051d02, 0x5c051e02, 0x5c051f02, 0x5c052002, 0x5c052102, + 0x5c052202, 0x5c052302, 0x5c052402, 0x5c052502, 0x5c052602, 0x5c052702, 0x5c052802, 0x5c052902, + 0x5c052a02, 0x5c052b02, 0x5c052c02, 0x5c052d02, 0x5c052e02, 0x5c052f02, 0x5c053002, 0x5c053102, + 0x5c053202, 0x5c053302, 0x5c053402, 0x5c053502, 0x5c053602, 0x5c053702, 0x5c053802, 0x5c053902, + 0x5c053a02, 0x5c053b02, 0x5c053c02, 0x5c053d02, 0x5c053e02, 0x5c053f02, 0x5c054002, 0x5c054102, + 0x5c054202, 0x5c054302, 0x5c054402, 0x5c054502, 0x5c054602, 0x5c054702, 0x5c054802, 0x5c054902, + 0x5c054a02, 0x5c054b02, 0x5c054c02, 0x5c054d02, 0x5c054e02, 0x5c054f02, 0x5c055002, 0x5c055102, + 0x5c055202, 0x5c055302, 0x5c055402, 0x5c055502, 0x5c055602, 0x5c055702, 0x5c055802, 0x5c055902, + 0x5c055a02, 0x5c055b02, 0x5c055c02, 0x5c055d02, 0x5c055e02, 0x5c055f02, 0x5c056002, 0x5c056102, + 0x5c056202, 0x5c056302, 0x5c056402, 0x5c056502, 0x5c056602, 0x5c056702, 0x5c056802, 0x5c056902, + 0x5c056a02, 0x5c056b02, 0x5c056c02, 0x5c056d02, 0x5c056e02, 0x5c056f02, 0x5c057002, 0x5c057102, + 0x5c057202, 0x5c057302, 0x5c057402, 0x5c057502, 0x5c057602, 0x5c057702, 0x5c057802, 0x5c057902, + 0x5c057a02, 0x5c057b02, 0x5c057c02, 0x5c057d02, 0x5c057e02, 0x5c057f02, 0x5c058002, 0x5c058102, + 0x5c058202, 0x5c058302, 0x5c058402, 0x5c058502, 0x5c058602, 0x5c058702, 0x5c058802, 0x5c058902, + 0x5c058a02, 0x5c058b02, 0x5c058c02, 0x5c058d02, 0x5c058e02, 0x5c058f02, 0x5c059002, 0x5c059102, + 0x5c059202, 0x5c059302, 0x5c059402, 0x5c059502, 0x5c059602, 0x5c059702, 0x5c059802, 0x5c059902, + 0x5c059a02, 0x5c059b02, 0x5c059c02, 0x5c059d02, 0x5c059e02, 0x5c059f02, 0x5c05a002, 0x5c05a102, + 0x5c05a202, 0x5c05a302, 0x5c05a402, 0x5c05a502, 0x5c05a602, 0x5c05a702, 0x5c05a802, 0x5c05a902, + 0x5c05aa02, 0x5c05ab02, 0x5c05ac02, 0x5c05ad02, 0x5c05ae02, 0x5c05af02, 0x5c05b002, 0x5c05b102, + 0x5c05b202, 0x5c05b302, 0x5c05b402, 0x5c05b502, 0x5c05b602, 0x5c05b702, 0x5c05b802, 0x5c05b902, + 0x5c05ba02, 0x5c05bb02, 0x5c05bc02, 0x5c05bd02, 0x5c05be02, 0x5c05bf02, 0x5c05c002, 0x5c05c102, + 0x5c05c202, 0x5c05c302, 0x5c05c402, 0x5c05c502, 0x5c05c602, 0x5c05c702, 0x5c05c802, 0x5c05c902, + 0x5c05ca02, 0x5c05cb02, 0x5c05cc02, 0x5c05cd02, 0x5c05ce02, 0x5c05cf02, 0x5c05d002, 0x5c05d102, + 0x5c05d202, 0x5c05d302, 0x5c05d402, 0x5c05d502, 0x5c05d602, 0x5c05d702, 0x5c05d802, 0x5c05d902, + 0x5c05da02, 0x5c05db02, 0x5c05dc02, 0x5c05dd02, 0x5c05de02, 0x5c05df02, 0x5c05e002, 0x5c05e102, + 0x5c05e202, 0x5c05e302, 0x5c05e402, 0x5c05e502, 0x5c05e602, 0x5c05e702, 0x5c05e802, 0x5c05e902, + 0x5c05ea02, 0x5c05eb02, 0x5c05ec02, 0x5c05ed02, 0x5c05ee02, 0x5c05ef02, 0x5c05f002, 0x5c05f102, + 0x5c05f202, 0x5c05f302, 0x5c05f402, 0x5c05f502, 0x5c05f602, 0x5c05f702, 0x5c05f802, 0x5c05f902, + 0x5c05fa02, 0x5c05fb02, 0x5c05fc02, 0x5c05fd02, 0x5c05fe02, 0x5c05ff02, 0x5d050202, 0x5d050302, + 0x5d050402, 0x5d050502, 0x5d050602, 0x5d050702, 0x5d050802, 0x5d050902, 0x5d050a02, 0x5d050b02, + 0x5d050c02, 0x5d050d02, 0x5d050e02, 0x5d050f02, 0x5d051002, 0x5d051102, 0x5d051202, 0x5d051302, + 0x5d051402, 0x5d051502, 0x5d051602, 0x5d051702, 0x5d051802, 0x5d051902, 0x5d051a02, 0x5d051b02, + 0x5d051c02, 0x5d051d02, 0x5d051e02, 0x5d051f02, 0x5d052002, 0x5d052102, 0x5d052202, 0x5d052302, + 0x5d052402, 0x5d052502, 0x5d052602, 0x5d052702, 0x5d052802, 0x5d052902, 0x5d052a02, 0x5d052b02, + 0x5d052c02, 0x5d052d02, 0x5d052e02, 0x5d052f02, 0x5d053002, 0x5d053102, 0x5d053202, 0x5d053302, + 0x5d053402, 0x5d053502, 0x5d053602, 0x5d053702, 0x5d053802, 0x5d053902, 0x5d053a02, 0x5d053b02, + 0x5d053c02, 0x5d053d02, 0x5d053e02, 0x5d053f02, 0x5d054002, 0x5d054102, 0x5d054202, 0x5d054302, + 0x5d054402, 0x5d054502, 0x5d054602, 0x5d054702, 0x5d054802, 0x5d054902, 0x5d054a02, 0x5d054b02, + 0x5d054c02, 0x5d054d02, 0x5d054e02, 0x5d054f02, 0x5d055002, 0x5d055102, 0x5d055202, 0x5d055302, + 0x5d055402, 0x5d055502, 0x5d055602, 0x5d055702, 0x5d055802, 0x5d055902, 0x5d055a02, 0x5d055b02, + 0x5d055c02, 0x5d055d02, 0x5d055e02, 0x5d055f02, 0x5d056002, 0x5d056102, 0x5d056202, 0x5d056302, + 0x5d056402, 0x5d056502, 0x5d056602, 0x5d056702, 0x5d056802, 0x5d056902, 0x5d056a02, 0x5d056b02, + 0x5d056c02, 0x5d056d02, 0x5d056e02, 0x5d056f02, 0x5d057002, 0x5d057102, 0x5d057202, 0x5d057302, + 0x5d057402, 0x5d057502, 0x5d057602, 0x5d057702, 0x5d057802, 0x5d057902, 0x5d057a02, 0x5d057b02, + 0x5d057c02, 0x5d057d02, 0x5d057e02, 0x5d057f02, 0x5d058002, 0x5d058102, 0x5d058202, 0x5d058302, + 0x5d058402, 0x5d058502, 0x5d058602, 0x5d058702, 0x5d058802, 0x5d058902, 0x5d058a02, 0x5d058b02, + 0x5d058c02, 0x5d058d02, 0x5d058e02, 0x5d058f02, 0x5d059002, 0x5d059102, 0x5d059202, 0x5d059302, + 0x5d059402, 0x5d059502, 0x5d059602, 0x5d059702, 0x5d059802, 0x5d059902, 0x5d059a02, 0x5d059b02, + 0x5d059c02, 0x5d059d02, 0x5d059e02, 0x5d059f02, 0x5d05a002, 0x5d05a102, 0x5d05a202, 0x5d05a302, + 0x5d05a402, 0x5d05a502, 0x5d05a602, 0x5d05a702, 0x5d05a802, 0x5d05a902, 0x5d05aa02, 0x5d05ab02, + 0x5d05ac02, 0x5d05ad02, 0x5d05ae02, 0x5d05af02, 0x5d05b002, 0x5d05b102, 0x5d05b202, 0x5d05b302, + 0x5d05b402, 0x5d05b502, 0x5d05b602, 0x5d05b702, 0x5d05b802, 0x5d05b902, 0x5d05ba02, 0x5d05bb02, + 0x5d05bc02, 0x5d05bd02, 0x5d05be02, 0x5d05bf02, 0x5d05c002, 0x5d05c102, 0x5d05c202, 0x5d05c302, + 0x5d05c402, 0x5d05c502, 0x5d05c602, 0x5d05c702, 0x5d05c802, 0x5d05c902, 0x5d05ca02, 0x5d05cb02, + 0x5d05cc02, 0x5d05cd02, 0x5d05ce02, 0x5d05cf02, 0x5d05d002, 0x5d05d102, 0x5d05d202, 0x5d05d302, + 0x5d05d402, 0x5d05d502, 0x5d05d602, 0x5d05d702, 0x5d05d802, 0x5d05d902, 0x5d05da02, 0x5d05db02, + 0x5d05dc02, 0x5d05dd02, 0x5d05de02, 0x5d05df02, 0x5d05e002, 0x5d05e102, 0x5d05e202, 0x5d05e302, + 0x5d05e402, 0x5d05e502, 0x5d05e602, 0x5d05e702, 0x5d05e802, 0x5d05e902, 0x5d05ea02, 0x5d05eb02, + 0x5d05ec02, 0x5d05ed02, 0x5d05ee02, 0x5d05ef02, 0x5d05f002, 0x5d05f102, 0x5d05f202, 0x5d05f302, + 0x5d05f402, 0x5d05f502, 0x5d05f602, 0x5d05f702, 0x5d05f802, 0x5d05f902, 0x5d05fa02, 0x5d05fb02, + 0x5d05fc02, 0x5d05fd02, 0x5d05fe02, 0x5d05ff02, 0x5e050202, 0x5e050302, 0x5e050402, 0x5e050502, + 0x5e050602, 0x5e050702, 0x5e050802, 0x5e050902, 0x5e050a02, 0x5e050b02, 0x5e050c02, 0x5e050d02, + 0x5e050e02, 0x5e050f02, 0x5e051002, 0x5e051102, 0x5e051202, 0x5e051302, 0x5e051402, 0x5e051502, + 0x5e051602, 0x5e051702, 0x5e051802, 0x5e051902, 0x5e051a02, 0x5e051b02, 0x5e051c02, 0x5e051d02, + 0x5e051e02, 0x5e051f02, 0x5e052002, 0x5e052102, 0x5e052202, 0x5e052302, 0x5e052402, 0x5e052502, + 0x5e052602, 0x5e052702, 0x5e052802, 0x5e052902, 0x5e052a02, 0x5e052b02, 0x5e052c02, 0x5e052d02, + 0x5e052e02, 0x5e052f02, 0x5e053002, 0x5e053102, 0x5e053202, 0x5e053302, 0x5e053402, 0x5e053502, + 0x5e053602, 0x5e053702, 0x5e053802, 0x5e053902, 0x5e053a02, 0x5e053b02, 0x5e053c02, 0x5e053d02, + 0x5e053e02, 0x5e053f02, 0x5e054002, 0x5e054102, 0x5e054202, 0x5e054302, 0x5e054402, 0x5e054502, + 0x5e054602, 0x5e054702, 0x5e054802, 0x5e054902, 0x5e054a02, 0x5e054b02, 0x5e054c02, 0x5e054d02, + 0x5e054e02, 0x5e054f02, 0x5e055002, 0x5e055102, 0x5e055202, 0x5e055302, 0x5e055402, 0x5e055502, + 0x5e055602, 0x5e055702, 0x5e055802, 0x5e055902, 0x5e055a02, 0x5e055b02, 0x5e055c02, 0x5e055d02, + 0x5e055e02, 0x5e055f02, 0x5e056002, 0x5e056102, 0x5e056202, 0x5e056302, 0x5e056402, 0x5e056502, + 0x5e056602, 0x5e056702, 0x5e056802, 0x5e056902, 0x5e056a02, 0x5e056b02, 0x5e056c02, 0x5e056d02, + 0x5e056e02, 0x5e056f02, 0x5e057002, 0x5e057102, 0x5e057202, 0x5e057302, 0x5e057402, 0x5e057502, + 0x5e057602, 0x5e057702, 0x5e057802, 0x5e057902, 0x5e057a02, 0x5e057b02, 0x5e057c02, 0x5e057d02, + 0x5e057e02, 0x5e057f02, 0x5e058002, 0x5e058102, 0x5e058202, 0x5e058302, 0x5e058402, 0x5e058502, + 0x5e058602, 0x5e058702, 0x5e058802, 0x5e058902, 0x5e058a02, 0x5e058b02, 0x5e058c02, 0x5e058d02, + 0x5e058e02, 0x5e058f02, 0x5e059002, 0x5e059102, 0x5e059202, 0x5e059302, 0x5e059402, 0x5e059502, + 0x5e059602, 0x5e059702, 0x5e059802, 0x5e059902, 0x5e059a02, 0x5e059b02, 0x5e059c02, 0x5e059d02, + 0x5e059e02, 0x5e059f02, 0x5e05a002, 0x5e05a102, 0x5e05a202, 0x5e05a302, 0x5e05a402, 0x5e05a502, + 0x5e05a602, 0x5e05a702, 0x5e05a802, 0x5e05a902, 0x5e05aa02, 0x5e05ab02, 0x5e05ac02, 0x5e05ad02, + 0x5e05ae02, 0x5e05af02, 0x5e05b002, 0x5e05b102, 0x5e05b202, 0x5e05b302, 0x5e05b402, 0x5e05b502, + 0x5e05b602, 0x5e05b702, 0x5e05b802, 0x5e05b902, 0x5e05ba02, 0x5e05bb02, 0x5e05bc02, 0x5e05bd02, + 0x5e05be02, 0x5e05bf02, 0x5e05c002, 0x5e05c102, 0x5e05c202, 0x5e05c302, 0x5e05c402, 0x5e05c502, + 0x5e05c602, 0x5e05c702, 0x5e05c802, 0x5e05c902, 0x5e05ca02, 0x5e05cb02, 0x5e05cc02, 0x5e05cd02, + 0x5e05ce02, 0x5e05cf02, 0x5e05d002, 0x5e05d102, 0x5e05d202, 0x5e05d302, 0x5e05d402, 0x5e05d502, + 0x5e05d602, 0x5e05d702, 0x5e05d802, 0x5e05d902, 0x5e05da02, 0x5e05db02, 0x5e05dc02, 0x5e05dd02, + 0x5e05de02, 0x5e05df02, 0x5e05e002, 0x5e05e102, 0x5e05e202, 0x5e05e302, 0x5e05e402, 0x5e05e502, + 0x5e05e602, 0x5e05e702, 0x5e05e802, 0x5e05e902, 0x5e05ea02, 0x5e05eb02, 0x5e05ec02, 0x5e05ed02, + 0x5e05ee02, 0x5e05ef02, 0x5e05f002, 0x5e05f102, 0x5e05f202, 0x5e05f302, 0x5e05f402, 0x5e05f502, + 0x5e05f602, 0x5e05f702, 0x5e05f802, 0x5e05f902, 0x5e05fa02, 0x5e05fb02, 0x5e05fc02, 0x5e05fd02, + 0x5e05fe02, 0x5e05ff02, 0x5f050202, 0x5f050302, 0x5f050402, 0x5f050502, 0x5f050602, 0x5f050702, + 0x5f050802, 0x5f050902, 0x5f050a02, 0x5f050b02, 0x5f050c02, 0x5f050d02, 0x5f050e02, 0x5f050f02, + 0x5f051002, 0x5f051102, 0x5f051202, 0x5f051302, 0x5f051402, 0x5f051502, 0x5f051602, 0x5f051702, + 0x5f051802, 0x5f051902, 0x5f051a02, 0x5f051b02, 0x5f051c02, 0x5f051d02, 0x5f051e02, 0x5f051f02, + 0x5f052002, 0x5f052102, 0x5f052202, 0x5f052302, 0x5f052402, 0x5f052502, 0x5f052602, 0x5f052702, + 0x5f052802, 0x5f052902, 0x5f052a02, 0x5f052b02, 0x5f052c02, 0x5f052d02, 0x5f052e02, 0x5f052f02, + 0x5f053002, 0x5f053102, 0x5f053202, 0x5f053302, 0x5f053402, 0x5f053502, 0x5f053602, 0x5f053702, + 0x5f053802, 0x5f053902, 0x5f053a02, 0x5f053b02, 0x5f053c02, 0x5f053d02, 0x5f053e02, 0x5f053f02, + 0x5f054002, 0x5f054102, 0x5f054202, 0x5f054302, 0x5f054402, 0x5f054502, 0x5f054602, 0x5f054702, + 0x5f054802, 0x5f054902, 0x5f054a02, 0x5f054b02, 0x5f054c02, 0x5f054d02, 0x5f054e02, 0x5f054f02, + 0x5f055002, 0x5f055102, 0x5f055202, 0x5f055302, 0x5f055402, 0x5f055502, 0x5f055602, 0x5f055702, + 0x5f055802, 0x5f055902, 0x5f055a02, 0x5f055b02, 0x5f055c02, 0x5f055d02, 0x5f055e02, 0x5f055f02, + 0x5f056002, 0x5f056102, 0x5f056202, 0x5f056302, 0x5f056402, 0x5f056502, 0x5f056602, 0x5f056702, + 0x5f056802, 0x5f056902, 0x5f056a02, 0x5f056b02, 0x5f056c02, 0x5f056d02, 0x5f056e02, 0x5f056f02, + 0x5f057002, 0x5f057102, 0x5f057202, 0x5f057302, 0x5f057402, 0x5f057502, 0x5f057602, 0x5f057702, + 0x5f057802, 0x5f057902, 0x5f057a02, 0x5f057b02, 0x5f057c02, 0x5f057d02, 0x5f057e02, 0x5f057f02, + 0x5f058002, 0x5f058102, 0x5f058202, 0x5f058302, 0x5f058402, 0x5f058502, 0x5f058602, 0x5f058702, + 0x5f058802, 0x5f058902, 0x5f058a02, 0x5f058b02, 0x5f058c02, 0x5f058d02, 0x5f058e02, 0x5f058f02, + 0x5f059002, 0x5f059102, 0x5f059202, 0x5f059302, 0x5f059402, 0x5f059502, 0x5f059602, 0x5f059702, + 0x5f059802, 0x5f059902, 0x5f059a02, 0x5f059b02, 0x5f059c02, 0x5f059d02, 0x5f059e02, 0x5f059f02, + 0x5f05a002, 0x5f05a102, 0x5f05a202, 0x5f05a302, 0x5f05a402, 0x5f05a502, 0x5f05a602, 0x5f05a702, + 0x5f05a802, 0x5f05a902, 0x5f05aa02, 0x5f05ab02, 0x5f05ac02, 0x5f05ad02, 0x5f05ae02, 0x5f05af02, + 0x5f05b002, 0x5f05b102, 0x5f05b202, 0x5f05b302, 0x5f05b402, 0x5f05b502, 0x5f05b602, 0x5f05b702, + 0x5f05b802, 0x5f05b902, 0x5f05ba02, 0x5f05bb02, 0x5f05bc02, 0x5f05bd02, 0x5f05be02, 0x5f05bf02, + 0x5f05c002, 0x5f05c102, 0x5f05c202, 0x5f05c302, 0x5f05c402, 0x5f05c502, 0x5f05c602, 0x5f05c702, + 0x5f05c802, 0x5f05c902, 0x5f05ca02, 0x5f05cb02, 0x5f05cc02, 0x5f05cd02, 0x5f05ce02, 0x5f05cf02, + 0x5f05d002, 0x5f05d102, 0x5f05d202, 0x5f05d302, 0x5f05d402, 0x5f05d502, 0x5f05d602, 0x5f05d702, + 0x5f05d802, 0x5f05d902, 0x5f05da02, 0x5f05db02, 0x5f05dc02, 0x5f05dd02, 0x5f05de02, 0x5f05df02, + 0x5f05e002, 0x5f05e102, 0x5f05e202, 0x5f05e302, 0x5f05e402, 0x5f05e502, 0x5f05e602, 0x5f05e702, + 0x5f05e802, 0x5f05e902, 0x5f05ea02, 0x5f05eb02, 0x5f05ec02, 0x5f05ed02, 0x5f05ee02, 0x5f05ef02, + 0x5f05f002, 0x5f05f102, 0x5f05f202, 0x5f05f302, 0x5f05f402, 0x5f05f502, 0x5f05f602, 0x5f05f702, + 0x5f05f802, 0x5f05f902, 0x5f05fa02, 0x5f05fb02, 0x5f05fc02, 0x5f05fd02, 0x5f05fe02, 0x5f05ff02, + 0x60050202, 0x60050302, 0x60050402, 0x60050502, 0x60050602, 0x60050702, 0x60050802, 0x60050902, + 0x60050a02, 0x60050b02, 0x60050c02, 0x60050d02, 0x60050e02, 0x60050f02, 0x60051002, 0x60051102, + 0x60051202, 0x60051302, 0x60051402, 0x60051502, 0x60051602, 0x60051702, 0x60051802, 0x60051902, + 0x60051a02, 0x60051b02, 0x60051c02, 0x60051d02, 0x60051e02, 0x60051f02, 0x60052002, 0x60052102, + 0x60052202, 0x60052302, 0x60052402, 0x60052502, 0x60052602, 0x60052702, 0x60052802, 0x60052902, + 0x60052a02, 0x60052b02, 0x60052c02, 0x60052d02, 0x60052e02, 0x60052f02, 0x60053002, 0x60053102, + 0x60053202, 0x60053302, 0x60053402, 0x60053502, 0x60053602, 0x60053702, 0x60053802, 0x60053902, + 0x60053a02, 0x60053b02, 0x60053c02, 0x60053d02, 0x60053e02, 0x60053f02, 0x60054002, 0x60054102, + 0x60054202, 0x60054302, 0x60054402, 0x60054502, 0x60054602, 0x60054702, 0x60054802, 0x60054902, + 0x60054a02, 0x60054b02, 0x60054c02, 0x60054d02, 0x60054e02, 0x60054f02, 0x60055002, 0x60055102, + 0x60055202, 0x60055302, 0x60055402, 0x60055502, 0x60055602, 0x60055702, 0x60055802, 0x60055902, + 0x60055a02, 0x60055b02, 0x60055c02, 0x60055d02, 0x60055e02, 0x60055f02, 0x60056002, 0x60056102, + 0x60056202, 0x60056302, 0x60056402, 0x60056502, 0x60056602, 0x60056702, 0x60056802, 0x60056902, + 0x60056a02, 0x60056b02, 0x60056c02, 0x60056d02, 0x60056e02, 0x60056f02, 0x60057002, 0x60057102, + 0x60057202, 0x60057302, 0x60057402, 0x60057502, 0x60057602, 0x60057702, 0x60057802, 0x60057902, + 0x60057a02, 0x60057b02, 0x60057c02, 0x60057d02, 0x60057e02, 0x60057f02, 0x60058002, 0x60058102, + 0x60058202, 0x60058302, 0x60058402, 0x60058502, 0x60058602, 0x60058702, 0x60058802, 0x60058902, + 0x60058a02, 0x60058b02, 0x60058c02, 0x60058d02, 0x60058e02, 0x60058f02, 0x60059002, 0x60059102, + 0x60059202, 0x60059302, 0x60059402, 0x60059502, 0x60059602, 0x60059702, 0x60059802, 0x60059902, + 0x60059a02, 0x60059b02, 0x60059c02, 0x60059d02, 0x60059e02, 0x60059f02, 0x6005a002, 0x6005a102, + 0x6005a202, 0x6005a302, 0x6005a402, 0x6005a502, 0x6005a602, 0x6005a702, 0x6005a802, 0x6005a902, + 0x6005aa02, 0x6005ab02, 0x6005ac02, 0x6005ad02, 0x6005ae02, 0x6005af02, 0x6005b002, 0x6005b102, + 0x6005b202, 0x6005b302, 0x6005b402, 0x6005b502, 0x6005b602, 0x6005b702, 0x6005b802, 0x6005b902, + 0x6005ba02, 0x6005bb02, 0x6005bc02, 0x6005bd02, 0x6005be02, 0x6005bf02, 0x6005c002, 0x6005c102, + 0x6005c202, 0x6005c302, 0x6005c402, 0x6005c502, 0x6005c602, 0x6005c702, 0x6005c802, 0x6005c902, + 0x6005ca02, 0x6005cb02, 0x6005cc02, 0x6005cd02, 0x6005ce02, 0x6005cf02, 0x6005d002, 0x6005d102, + 0x6005d202, 0x6005d302, 0x6005d402, 0x6005d502, 0x6005d602, 0x6005d702, 0x6005d802, 0x6005d902, + 0x6005da02, 0x6005db02, 0x6005dc02, 0x6005dd02, 0x6005de02, 0x6005df02, 0x6005e002, 0x6005e102, + 0x6005e202, 0x6005e302, 0x6005e402, 0x6005e502, 0x6005e602, 0x6005e702, 0x6005e802, 0x6005e902, + 0x6005ea02, 0x6005eb02, 0x6005ec02, 0x6005ed02, 0x6005ee02, 0x6005ef02, 0x6005f002, 0x6005f102, + 0x6005f202, 0x6005f302, 0x6005f402, 0x6005f502, 0x6005f602, 0x6005f702, 0x6005f802, 0x6005f902, + 0x6005fa02, 0x6005fb02, 0x6005fc02, 0x6005fd02, 0x6005fe02, 0x6005ff02, 0x61050202, 0x61050302, + 0x61050402, 0x61050502, 0x61050602, 0x61050702, 0x61050802, 0x61050902, 0x61050a02, 0x61050b02, + 0x61050c02, 0x61050d02, 0x61050e02, 0x61050f02, 0x61051002, 0x61051102, 0x61051202, 0x61051302, + 0x61051402, 0x61051502, 0x61051602, 0x61051702, 0x61051802, 0x61051902, 0x61051a02, 0x61051b02, + 0x61051c02, 0x61051d02, 0x61051e02, 0x61051f02, 0x61052002, 0x61052102, 0x61052202, 0x61052302, + 0x61052402, 0x61052502, 0x61052602, 0x61052702, 0x61052802, 0x61052902, 0x61052a02, 0x61052b02, + 0x61052c02, 0x61052d02, 0x61052e02, 0x61052f02, 0x61053002, 0x61053102, 0x61053202, 0x61053302, + 0x61053402, 0x61053502, 0x61053602, 0x61053702, 0x61053802, 0x61053902, 0x61053a02, 0x61053b02, + 0x61053c02, 0x61053d02, 0x61053e02, 0x61053f02, 0x61054002, 0x61054102, 0x61054202, 0x61054302, + 0x61054402, 0x61054502, 0x61054602, 0x61054702, 0x61054802, 0x61054902, 0x61054a02, 0x61054b02, + 0x61054c02, 0x61054d02, 0x61054e02, 0x61054f02, 0x61055002, 0x61055102, 0x61055202, 0x61055302, + 0x61055402, 0x61055502, 0x61055602, 0x61055702, 0x61055802, 0x61055902, 0x61055a02, 0x61055b02, + 0x61055c02, 0x61055d02, 0x61055e02, 0x61055f02, 0x61056002, 0x61056102, 0x61056202, 0x61056302, + 0x61056402, 0x61056502, 0x61056602, 0x61056702, 0x61056802, 0x61056902, 0x61056a02, 0x61056b02, + 0x61056c02, 0x61056d02, 0x61056e02, 0x61056f02, 0x61057002, 0x61057102, 0x61057202, 0x61057302, + 0x61057402, 0x61057502, 0x61057602, 0x61057702, 0x61057802, 0x61057902, 0x61057a02, 0x61057b02, + 0x61057c02, 0x61057d02, 0x61057e02, 0x61057f02, 0x61058002, 0x61058102, 0x61058202, 0x61058302, + 0x61058402, 0x61058502, 0x61058602, 0x61058702, 0x61058802, 0x61058902, 0x61058a02, 0x61058b02, + 0x61058c02, 0x61058d02, 0x61058e02, 0x61058f02, 0x61059002, 0x61059102, 0x61059202, 0x61059302, + 0x61059402, 0x61059502, 0x61059602, 0x61059702, 0x61059802, 0x61059902, 0x61059a02, 0x61059b02, + 0x61059c02, 0x61059d02, 0x61059e02, 0x61059f02, 0x6105a002, 0x6105a102, 0x6105a202, 0x6105a302, + 0x6105a402, 0x6105a502, 0x6105a602, 0x6105a702, 0x6105a802, 0x6105a902, 0x6105aa02, 0x6105ab02, + 0x6105ac02, 0x6105ad02, 0x6105ae02, 0x6105af02, 0x6105b002, 0x6105b102, 0x6105b202, 0x6105b302, + 0x6105b402, 0x6105b502, 0x6105b602, 0x6105b702, 0x6105b802, 0x6105b902, 0x6105ba02, 0x6105bb02, + 0x6105bc02, 0x6105bd02, 0x6105be02, 0x6105bf02, 0x6105c002, 0x6105c102, 0x6105c202, 0x6105c302, + 0x6105c402, 0x6105c502, 0x6105c602, 0x6105c702, 0x6105c802, 0x6105c902, 0x6105ca02, 0x6105cb02, + 0x6105cc02, 0x6105cd02, 0x6105ce02, 0x6105cf02, 0x6105d002, 0x6105d102, 0x6105d202, 0x6105d302, + 0x6105d402, 0x6105d502, 0x6105d602, 0x6105d702, 0x6105d802, 0x6105d902, 0x6105da02, 0x6105db02, + 0x6105dc02, 0x6105dd02, 0x6105de02, 0x6105df02, 0x6105e002, 0x6105e102, 0x6105e202, 0x6105e302, + 0x6105e402, 0x6105e502, 0x6105e602, 0x6105e702, 0x6105e802, 0x6105e902, 0x6105ea02, 0x6105eb02, + 0x6105ec02, 0x6105ed02, 0x6105ee02, 0x6105ef02, 0x6105f002, 0x6105f102, 0x6105f202, 0x6105f302, + 0x6105f402, 0x6105f502, 0x6105f602, 0x6105f702, 0x6105f802, 0x6105f902, 0x6105fa02, 0x6105fb02, + 0x6105fc02, 0x6105fd02, 0x6105fe02, 0x6105ff02, 0x62050202, 0x62050302, 0x62050402, 0x62050502, + 0x62050602, 0x62050702, 0x62050802, 0x62050902, 0x62050a02, 0x62050b02, 0x62050c02, 0x62050d02, + 0x62050e02, 0x62050f02, 0x62051002, 0x62051102, 0x62051202, 0x62051302, 0x62051402, 0x62051502, + 0x62051602, 0x62051702, 0x62051802, 0x62051902, 0x62051a02, 0x62051b02, 0x62051c02, 0x62051d02, + 0x62051e02, 0x62051f02, 0x62052002, 0x62052102, 0x62052202, 0x62052302, 0x62052402, 0x62052502, + 0x62052602, 0x62052702, 0x62052802, 0x62052902, 0x62052a02, 0x62052b02, 0x62052c02, 0x62052d02, + 0x62052e02, 0x62052f02, 0x62053002, 0x62053102, 0x62053202, 0x62053302, 0x62053402, 0x62053502, + 0x62053602, 0x62053702, 0x62053802, 0x62053902, 0x62053a02, 0x62053b02, 0x62053c02, 0x62053d02, + 0x62053e02, 0x62053f02, 0x62054002, 0x62054102, 0x62054202, 0x62054302, 0x62054402, 0x62054502, + 0x62054602, 0x62054702, 0x62054802, 0x62054902, 0x62054a02, 0x62054b02, 0x62054c02, 0x62054d02, + 0x62054e02, 0x62054f02, 0x62055002, 0x62055102, 0x62055202, 0x62055302, 0x62055402, 0x62055502, + 0x62055602, 0x62055702, 0x62055802, 0x62055902, 0x62055a02, 0x62055b02, 0x62055c02, 0x62055d02, + 0x62055e02, 0x62055f02, 0x62056002, 0x62056102, 0x62056202, 0x62056302, 0x62056402, 0x62056502, + 0x62056602, 0x62056702, 0x62056802, 0x62056902, 0x62056a02, 0x62056b02, 0x62056c02, 0x62056d02, + 0x62056e02, 0x62056f02, 0x62057002, 0x62057102, 0x62057202, 0x62057302, 0x62057402, 0x62057502, + 0x62057602, 0x62057702, 0x62057802, 0x62057902, 0x62057a02, 0x62057b02, 0x62057c02, 0x62057d02, + 0x62057e02, 0x62057f02, 0x62058002, 0x62058102, 0x62058202, 0x62058302, 0x62058402, 0x62058502, + 0x62058602, 0x62058702, 0x62058802, 0x62058902, 0x62058a02, 0x62058b02, 0x62058c02, 0x62058d02, + 0x62058e02, 0x62058f02, 0x62059002, 0x62059102, 0x62059202, 0x62059302, 0x62059402, 0x62059502, + 0x62059602, 0x62059702, 0x62059802, 0x62059902, 0x62059a02, 0x62059b02, 0x62059c02, 0x62059d02, + 0x62059e02, 0x62059f02, 0x6205a002, 0x6205a102, 0x6205a202, 0x6205a302, 0x6205a402, 0x6205a502, + 0x6205a602, 0x6205a702, 0x6205a802, 0x6205a902, 0x6205aa02, 0x6205ab02, 0x6205ac02, 0x6205ad02, + 0x6205ae02, 0x6205af02, 0x6205b002, 0x6205b102, 0x6205b202, 0x6205b302, 0x6205b402, 0x6205b502, + 0x6205b602, 0x6205b702, 0x6205b802, 0x6205b902, 0x6205ba02, 0x6205bb02, 0x6205bc02, 0x6205bd02, + 0x6205be02, 0x6205bf02, 0x6205c002, 0x6205c102, 0x6205c202, 0x6205c302, 0x6205c402, 0x6205c502, + 0x6205c602, 0x6205c702, 0x6205c802, 0x6205c902, 0x6205ca02, 0x6205cb02, 0x6205cc02, 0x6205cd02, + 0x6205ce02, 0x6205cf02, 0x6205d002, 0x6205d102, 0x6205d202, 0x6205d302, 0x6205d402, 0x6205d502, + 0x6205d602, 0x6205d702, 0x6205d802, 0x6205d902, 0x6205da02, 0x6205db02, 0x6205dc02, 0x6205dd02, + 0x6205de02, 0x6205df02, 0x6205e002, 0x6205e102, 0x6205e202, 0x6205e302, 0x6205e402, 0x6205e502, + 0x6205e602, 0x6205e702, 0x6205e802, 0x6205e902, 0x6205ea02, 0x6205eb02, 0x6205ec02, 0x6205ed02, + 0x6205ee02, 0x6205ef02, 0x6205f002, 0x6205f102, 0x6205f202, 0x6205f302, 0x6205f402, 0x6205f502, + 0x6205f602, 0x6205f702, 0x6205f802, 0x6205f902, 0x6205fa02, 0x6205fb02, 0x6205fc02, 0x6205fd02, + 0x6205fe02, 0x6205ff02, 0x63050202, 0x63050302, 0x63050402, 0x63050502, 0x63050602, 0x63050702, + 0x63050802, 0x63050902, 0x63050a02, 0x63050b02, 0x63050c02, 0x63050d02, 0x63050e02, 0x63050f02, + 0x63051002, 0x63051102, 0x63051202, 0x63051302, 0x63051402, 0x63051502, 0x63051602, 0x63051702, + 0x63051802, 0x63051902, 0x63051a02, 0x63051b02, 0x63051c02, 0x63051d02, 0x63051e02, 0x63051f02, + 0x63052002, 0x63052102, 0x63052202, 0x63052302, 0x63052402, 0x63052502, 0x63052602, 0x63052702, + 0x63052802, 0x63052902, 0x63052a02, 0x63052b02, 0x63052c02, 0x63052d02, 0x63052e02, 0x63052f02, + 0x63053002, 0x63053102, 0x63053202, 0x63053302, 0x63053402, 0x63053502, 0x63053602, 0x63053702, + 0x63053802, 0x63053902, 0x63053a02, 0x63053b02, 0x63053c02, 0x63053d02, 0x63053e02, 0x63053f02, + 0x63054002, 0x63054102, 0x63054202, 0x63054302, 0x63054402, 0x63054502, 0x63054602, 0x63054702, + 0x63054802, 0x63054902, 0x63054a02, 0x63054b02, 0x63054c02, 0x63054d02, 0x63054e02, 0x63054f02, + 0x63055002, 0x63055102, 0x63055202, 0x63055302, 0x63055402, 0x63055502, 0x63055602, 0x63055702, + 0x63055802, 0x63055902, 0x63055a02, 0x63055b02, 0x63055c02, 0x63055d02, 0x63055e02, 0x63055f02, + 0x63056002, 0x63056102, 0x63056202, 0x63056302, 0x63056402, 0x63056502, 0x63056602, 0x63056702, + 0x63056802, 0x63056902, 0x63056a02, 0x63056b02, 0x63056c02, 0x63056d02, 0x63056e02, 0x63056f02, + 0x63057002, 0x63057102, 0x63057202, 0x63057302, 0x63057402, 0x63057502, 0x63057602, 0x63057702, + 0x63057802, 0x63057902, 0x63057a02, 0x63057b02, 0x63057c02, 0x63057d02, 0x63057e02, 0x63057f02, + 0x63058002, 0x63058102, 0x63058202, 0x63058302, 0x63058402, 0x63058502, 0x63058602, 0x63058702, + 0x63058802, 0x63058902, 0x63058a02, 0x63058b02, 0x63058c02, 0x63058d02, 0x63058e02, 0x63058f02, + 0x63059002, 0x63059102, 0x63059202, 0x63059302, 0x63059402, 0x63059502, 0x63059602, 0x63059702, + 0x63059802, 0x63059902, 0x63059a02, 0x63059b02, 0x63059c02, 0x63059d02, 0x63059e02, 0x63059f02, + 0x6305a002, 0x6305a102, 0x6305a202, 0x6305a302, 0x6305a402, 0x6305a502, 0x6305a602, 0x6305a702, + 0x6305a802, 0x6305a902, 0x6305aa02, 0x6305ab02, 0x6305ac02, 0x6305ad02, 0x6305ae02, 0x6305af02, + 0x6305b002, 0x6305b102, 0x6305b202, 0x6305b302, 0x6305b402, 0x6305b502, 0x6305b602, 0x6305b702, + 0x6305b802, 0x6305b902, 0x6305ba02, 0x6305bb02, 0x6305bc02, 0x6305bd02, 0x6305be02, 0x6305bf02, + 0x6305c002, 0x6305c102, 0x6305c202, 0x6305c302, 0x6305c402, 0x6305c502, 0x6305c602, 0x6305c702, + 0x6305c802, 0x6305c902, 0x6305ca02, 0x6305cb02, 0x6305cc02, 0x6305cd02, 0x6305ce02, 0x6305cf02, + 0x6305d002, 0x6305d102, 0x6305d202, 0x6305d302, 0x6305d402, 0x6305d502, 0x6305d602, 0x6305d702, + 0x6305d802, 0x6305d902, 0x6305da02, 0x6305db02, 0x6305dc02, 0x6305dd02, 0x6305de02, 0x6305df02, + 0x6305e002, 0x6305e102, 0x6305e202, 0x6305e302, 0x6305e402, 0x6305e502, 0x6305e602, 0x6305e702, + 0x6305e802, 0x6305e902, 0x6305ea02, 0x6305eb02, 0x6305ec02, 0x6305ed02, 0x6305ee02, 0x6305ef02, + 0x6305f002, 0x6305f102, 0x6305f202, 0x6305f302, 0x6305f402, 0x6305f502, 0x6305f602, 0x6305f702, + 0x6305f802, 0x6305f902, 0x6305fa02, 0x6305fb02, 0x6305fc02, 0x6305fd02, 0x6305fe02, 0x6305ff02, + 0x64050202, 0x64050302, 0x64050402, 0x64050502, 0x64050602, 0x64050702, 0x64050802, 0x64050902, + 0x64050a02, 0x64050b02, 0x64050c02, 0x64050d02, 0x64050e02, 0x64050f02, 0x64051002, 0x64051102, + 0x64051202, 0x64051302, 0x64051402, 0x64051502, 0x64051602, 0x64051702, 0x64051802, 0x64051902, + 0x64051a02, 0x64051b02, 0x64051c02, 0x64051d02, 0x64051e02, 0x64051f02, 0x64052002, 0x64052102, + 0x64052202, 0x64052302, 0x64052402, 0x64052502, 0x64052602, 0x64052702, 0x64052802, 0x64052902, + 0x64052a02, 0x64052b02, 0x64052c02, 0x64052d02, 0x64052e02, 0x64052f02, 0x64053002, 0x64053102, + 0x64053202, 0x64053302, 0x64053402, 0x64053502, 0x64053602, 0x64053702, 0x64053802, 0x64053902, + 0x64053a02, 0x64053b02, 0x64053c02, 0x64053d02, 0x64053e02, 0x64053f02, 0x64054002, 0x64054102, + 0x64054202, 0x64054302, 0x64054402, 0x64054502, 0x64054602, 0x64054702, 0x64054802, 0x64054902, + 0x64054a02, 0x64054b02, 0x64054c02, 0x64054d02, 0x64054e02, 0x64054f02, 0x64055002, 0x64055102, + 0x64055202, 0x64055302, 0x64055402, 0x64055502, 0x64055602, 0x64055702, 0x64055802, 0x64055902, + 0x64055a02, 0x64055b02, 0x64055c02, 0x64055d02, 0x64055e02, 0x64055f02, 0x64056002, 0x64056102, + 0x64056202, 0x64056302, 0x64056402, 0x64056502, 0x64056602, 0x64056702, 0x64056802, 0x64056902, + 0x64056a02, 0x64056b02, 0x64056c02, 0x64056d02, 0x64056e02, 0x64056f02, 0x64057002, 0x64057102, + 0x64057202, 0x64057302, 0x64057402, 0x64057502, 0x64057602, 0x64057702, 0x64057802, 0x64057902, + 0x64057a02, 0x64057b02, 0x64057c02, 0x64057d02, 0x64057e02, 0x64057f02, 0x64058002, 0x64058102, + 0x64058202, 0x64058302, 0x64058402, 0x64058502, 0x64058602, 0x64058702, 0x64058802, 0x64058902, + 0x64058a02, 0x64058b02, 0x64058c02, 0x64058d02, 0x64058e02, 0x64058f02, 0x64059002, 0x64059102, + 0x64059202, 0x64059302, 0x64059402, 0x64059502, 0x64059602, 0x64059702, 0x64059802, 0x64059902, + 0x64059a02, 0x64059b02, 0x64059c02, 0x64059d02, 0x64059e02, 0x64059f02, 0x6405a002, 0x6405a102, + 0x6405a202, 0x6405a302, 0x6405a402, 0x6405a502, 0x6405a602, 0x6405a702, 0x6405a802, 0x6405a902, + 0x6405aa02, 0x6405ab02, 0x6405ac02, 0x6405ad02, 0x6405ae02, 0x6405af02, 0x6405b002, 0x6405b102, + 0x6405b202, 0x6405b302, 0x6405b402, 0x6405b502, 0x6405b602, 0x6405b702, 0x6405b802, 0x6405b902, + 0x6405ba02, 0x6405bb02, 0x6405bc02, 0x6405bd02, 0x6405be02, 0x6405bf02, 0x6405c002, 0x6405c102, + 0x6405c202, 0x6405c302, 0x6405c402, 0x6405c502, 0x6405c602, 0x6405c702, 0x6405c802, 0x6405c902, + 0x6405ca02, 0x6405cb02, 0x6405cc02, 0x6405cd02, 0x6405ce02, 0x6405cf02, 0x6405d002, 0x6405d102, + 0x6405d202, 0x6405d302, 0x6405d402, 0x6405d502, 0x6405d602, 0x6405d702, 0x6405d802, 0x6405d902, + 0x6405da02, 0x6405db02, 0x6405dc02, 0x6405dd02, 0x6405de02, 0x6405df02, 0x6405e002, 0x6405e102, + 0x6405e202, 0x6405e302, 0x6405e402, 0x6405e502, 0x6405e602, 0x6405e702, 0x6405e802, 0x6405e902, + 0x6405ea02, 0x6405eb02, 0x6405ec02, 0x6405ed02, 0x6405ee02, 0x6405ef02, 0x6405f002, 0x6405f102, + 0x6405f202, 0x6405f302, 0x6405f402, 0x6405f502, 0x6405f602, 0x6405f702, 0x6405f802, 0x6405f902, + 0x6405fa02, 0x6405fb02, 0x6405fc02, 0x6405fd02, 0x6405fe02, 0x6405ff02, 0x65050202, 0x65050302, + 0x65050402, 0x65050502, 0x65050602, 0x65050702, 0x65050802, 0x65050902, 0x65050a02, 0x65050b02, + 0x65050c02, 0x65050d02, 0x65050e02, 0x65050f02, 0x65051002, 0x65051102, 0x65051202, 0x65051302, + 0x65051402, 0x65051502, 0x65051602, 0x65051702, 0x65051802, 0x65051902, 0x65051a02, 0x65051b02, + 0x65051c02, 0x65051d02, 0x65051e02, 0x65051f02, 0x65052002, 0x65052102, 0x65052202, 0x65052302, + 0x65052402, 0x65052502, 0x65052602, 0x65052702, 0x65052802, 0x65052902, 0x65052a02, 0x65052b02, + 0x65052c02, 0x65052d02, 0x65052e02, 0x65052f02, 0x65053002, 0x65053102, 0x65053202, 0x65053302, + 0x65053402, 0x65053502, 0x65053602, 0x65053702, 0x65053802, 0x65053902, 0x65053a02, 0x65053b02, + 0x65053c02, 0x65053d02, 0x65053e02, 0x65053f02, 0x65054002, 0x65054102, 0x65054202, 0x65054302, + 0x65054402, 0x65054502, 0x65054602, 0x65054702, 0x65054802, 0x65054902, 0x65054a02, 0x65054b02, + 0x65054c02, 0x65054d02, 0x65054e02, 0x65054f02, 0x65055002, 0x65055102, 0x65055202, 0x65055302, + 0x65055402, 0x65055502, 0x65055602, 0x65055702, 0x65055802, 0x65055902, 0x65055a02, 0x65055b02, + 0x65055c02, 0x65055d02, 0x65055e02, 0x65055f02, 0x65056002, 0x65056102, 0x65056202, 0x65056302, + 0x65056402, 0x65056502, 0x65056602, 0x65056702, 0x65056802, 0x65056902, 0x65056a02, 0x65056b02, + 0x65056c02, 0x65056d02, 0x65056e02, 0x65056f02, 0x65057002, 0x65057102, 0x65057202, 0x65057302, + 0x65057402, 0x65057502, 0x65057602, 0x65057702, 0x65057802, 0x65057902, 0x65057a02, 0x65057b02, + 0x65057c02, 0x65057d02, 0x65057e02, 0x65057f02, 0x65058002, 0x65058102, 0x65058202, 0x65058302, + 0x65058402, 0x65058502, 0x65058602, 0x65058702, 0x65058802, 0x65058902, 0x65058a02, 0x65058b02, + 0x65058c02, 0x65058d02, 0x65058e02, 0x65058f02, 0x65059002, 0x65059102, 0x65059202, 0x65059302, + 0x65059402, 0x65059502, 0x65059602, 0x65059702, 0x65059802, 0x65059902, 0x65059a02, 0x65059b02, + 0x65059c02, 0x65059d02, 0x65059e02, 0x65059f02, 0x6505a002, 0x6505a102, 0x6505a202, 0x6505a302, + 0x6505a402, 0x6505a502, 0x6505a602, 0x6505a702, 0x6505a802, 0x6505a902, 0x6505aa02, 0x6505ab02, + 0x6505ac02, 0x6505ad02, 0x6505ae02, 0x6505af02, 0x6505b002, 0x6505b102, 0x6505b202, 0x6505b302, + 0x6505b402, 0x6505b502, 0x6505b602, 0x6505b702, 0x6505b802, 0x6505b902, 0x6505ba02, 0x6505bb02, + 0x6505bc02, 0x6505bd02, 0x6505be02, 0x6505bf02, 0x6505c002, 0x6505c102, 0x6505c202, 0x6505c302, + 0x6505c402, 0x6505c502, 0x6505c602, 0x6505c702, 0x6505c802, 0x6505c902, 0x6505ca02, 0x6505cb02, + 0x6505cc02, 0x6505cd02, 0x6505ce02, 0x6505cf02, 0x6505d002, 0x6505d102, 0x6505d202, 0x6505d302, + 0x6505d402, 0x6505d502, 0x6505d602, 0x6505d702, 0x6505d802, 0x6505d902, 0x6505da02, 0x6505db02, + 0x6505dc02, 0x6505dd02, 0x6505de02, 0x6505df02, 0x6505e002, 0x6505e102, 0x6505e202, 0x6505e302, + 0x6505e402, 0x6505e502, 0x6505e602, 0x6505e702, 0x6505e802, 0x6505e902, 0x6505ea02, 0x6505eb02, + 0x6505ec02, 0x6505ed02, 0x6505ee02, 0x6505ef02, 0x6505f002, 0x6505f102, 0x6505f202, 0x6505f302, + 0x6505f402, 0x6505f502, 0x6505f602, 0x6505f702, 0x6505f802, 0x6505f902, 0x6505fa02, 0x6505fb02, + 0x6505fc02, 0x6505fd02, 0x6505fe02, 0x6505ff02, 0x66050202, 0x66050302, 0x66050402, 0x66050502, + 0x66050602, 0x66050702, 0x66050802, 0x66050902, 0x66050a02, 0x66050b02, 0x66050c02, 0x66050d02, + 0x66050e02, 0x66050f02, 0x66051002, 0x66051102, 0x66051202, 0x66051302, 0x66051402, 0x66051502, + 0x66051602, 0x66051702, 0x66051802, 0x66051902, 0x66051a02, 0x66051b02, 0x66051c02, 0x66051d02, + 0x66051e02, 0x66051f02, 0x66052002, 0x66052102, 0x66052202, 0x66052302, 0x66052402, 0x66052502, + 0x66052602, 0x66052702, 0x66052802, 0x66052902, 0x66052a02, 0x66052b02, 0x66052c02, 0x66052d02, + 0x66052e02, 0x66052f02, 0x66053002, 0x66053102, 0x66053202, 0x66053302, 0x66053402, 0x66053502, + 0x66053602, 0x66053702, 0x66053802, 0x66053902, 0x66053a02, 0x66053b02, 0x66053c02, 0x66053d02, + 0x66053e02, 0x66053f02, 0x66054002, 0x66054102, 0x66054202, 0x66054302, 0x66054402, 0x66054502, + 0x66054602, 0x66054702, 0x66054802, 0x66054902, 0x66054a02, 0x66054b02, 0x66054c02, 0x66054d02, + 0x66054e02, 0x66054f02, 0x66055002, 0x66055102, 0x66055202, 0x66055302, 0x66055402, 0x66055502, + 0x66055602, 0x66055702, 0x66055802, 0x66055902, 0x66055a02, 0x66055b02, 0x66055c02, 0x66055d02, + 0x66055e02, 0x66055f02, 0x66056002, 0x66056102, 0x66056202, 0x66056302, 0x66056402, 0x66056502, + 0x66056602, 0x66056702, 0x66056802, 0x66056902, 0x66056a02, 0x66056b02, 0x66056c02, 0x66056d02, + 0x66056e02, 0x66056f02, 0x66057002, 0x66057102, 0x66057202, 0x66057302, 0x66057402, 0x66057502, + 0x66057602, 0x66057702, 0x66057802, 0x66057902, 0x66057a02, 0x66057b02, 0x66057c02, 0x66057d02, + 0x66057e02, 0x66057f02, 0x66058002, 0x66058102, 0x66058202, 0x66058302, 0x66058402, 0x66058502, + 0x66058602, 0x66058702, 0x66058802, 0x66058902, 0x66058a02, 0x66058b02, 0x66058c02, 0x66058d02, + 0x66058e02, 0x66058f02, 0x66059002, 0x66059102, 0x66059202, 0x66059302, 0x66059402, 0x66059502, + 0x66059602, 0x66059702, 0x66059802, 0x66059902, 0x66059a02, 0x66059b02, 0x66059c02, 0x66059d02, + 0x66059e02, 0x66059f02, 0x6605a002, 0x6605a102, 0x6605a202, 0x6605a302, 0x6605a402, 0x6605a502, + 0x6605a602, 0x6605a702, 0x6605a802, 0x6605a902, 0x6605aa02, 0x6605ab02, 0x6605ac02, 0x6605ad02, + 0x6605ae02, 0x6605af02, 0x6605b002, 0x6605b102, 0x6605b202, 0x6605b302, 0x6605b402, 0x6605b502, + 0x6605b602, 0x6605b702, 0x6605b802, 0x6605b902, 0x6605ba02, 0x6605bb02, 0x6605bc02, 0x6605bd02, + 0x6605be02, 0x6605bf02, 0x6605c002, 0x6605c102, 0x6605c202, 0x6605c302, 0x6605c402, 0x6605c502, + 0x6605c602, 0x6605c702, 0x6605c802, 0x6605c902, 0x6605ca02, 0x6605cb02, 0x6605cc02, 0x6605cd02, + 0x6605ce02, 0x6605cf02, 0x6605d002, 0x6605d102, 0x6605d202, 0x6605d302, 0x6605d402, 0x6605d502, + 0x6605d602, 0x6605d702, 0x6605d802, 0x6605d902, 0x6605da02, 0x6605db02, 0x6605dc02, 0x6605dd02, + 0x6605de02, 0x6605df02, 0x6605e002, 0x6605e102, 0x6605e202, 0x6605e302, 0x6605e402, 0x6605e502, + 0x6605e602, 0x6605e702, 0x6605e802, 0x6605e902, 0x6605ea02, 0x6605eb02, 0x6605ec02, 0x6605ed02, + 0x6605ee02, 0x6605ef02, 0x6605f002, 0x6605f102, 0x6605f202, 0x6605f302, 0x6605f402, 0x6605f502, + 0x6605f602, 0x6605f702, 0x6605f802, 0x6605f902, 0x6605fa02, 0x6605fb02, 0x6605fc02, 0x6605fd02, + 0x6605fe02, 0x6605ff02, 0x67050202, 0x67050302, 0x67050402, 0x67050502, 0x67050602, 0x67050702, + 0x67050802, 0x67050902, 0x67050a02, 0x67050b02, 0x67050c02, 0x67050d02, 0x67050e02, 0x67050f02, + 0x67051002, 0x67051102, 0x67051202, 0x67051302, 0x67051402, 0x67051502, 0x67051602, 0x67051702, + 0x67051802, 0x67051902, 0x67051a02, 0x67051b02, 0x67051c02, 0x67051d02, 0x67051e02, 0x67051f02, + 0x67052002, 0x67052102, 0x67052202, 0x67052302, 0x67052402, 0x67052502, 0x67052602, 0x67052702, + 0x67052802, 0x67052902, 0x67052a02, 0x67052b02, 0x67052c02, 0x67052d02, 0x67052e02, 0x67052f02, + 0x67053002, 0x67053102, 0x67053202, 0x67053302, 0x67053402, 0x67053502, 0x67053602, 0x67053702, + 0x67053802, 0x67053902, 0x67053a02, 0x67053b02, 0x67053c02, 0x67053d02, 0x67053e02, 0x67053f02, + 0x67054002, 0x67054102, 0x67054202, 0x67054302, 0x67054402, 0x67054502, 0x67054602, 0x67054702, + 0x67054802, 0x67054902, 0x67054a02, 0x67054b02, 0x67054c02, 0x67054d02, 0x67054e02, 0x67054f02, + 0x67055002, 0x67055102, 0x67055202, 0x67055302, 0x67055402, 0x67055502, 0x67055602, 0x67055702, + 0x67055802, 0x67055902, 0x67055a02, 0x67055b02, 0x67055c02, 0x67055d02, 0x67055e02, 0x67055f02, + 0x67056002, 0x67056102, 0x67056202, 0x67056302, 0x67056402, 0x67056502, 0x67056602, 0x67056702, + 0x67056802, 0x67056902, 0x67056a02, 0x67056b02, 0x67056c02, 0x67056d02, 0x67056e02, 0x67056f02, + 0x67057002, 0x67057102, 0x67057202, 0x67057302, 0x67057402, 0x67057502, 0x67057602, 0x67057702, + 0x67057802, 0x67057902, 0x67057a02, 0x67057b02, 0x67057c02, 0x67057d02, 0x67057e02, 0x67057f02, + 0x67058002, 0x67058102, 0x67058202, 0x67058302, 0x67058402, 0x67058502, 0x67058602, 0x67058702, + 0x67058802, 0x67058902, 0x67058a02, 0x67058b02, 0x67058c02, 0x67058d02, 0x67058e02, 0x67058f02, + 0x67059002, 0x67059102, 0x67059202, 0x67059302, 0x67059402, 0x67059502, 0x67059602, 0x67059702, + 0x67059802, 0x67059902, 0x67059a02, 0x67059b02, 0x67059c02, 0x67059d02, 0x67059e02, 0x67059f02, + 0x6705a002, 0x6705a102, 0x6705a202, 0x6705a302, 0x6705a402, 0x6705a502, 0x6705a602, 0x6705a702, + 0x6705a802, 0x6705a902, 0x6705aa02, 0x6705ab02, 0x6705ac02, 0x6705ad02, 0x6705ae02, 0x6705af02, + 0x6705b002, 0x6705b102, 0x6705b202, 0x6705b302, 0x6705b402, 0x6705b502, 0x6705b602, 0x6705b702, + 0x6705b802, 0x6705b902, 0x6705ba02, 0x6705bb02, 0x6705bc02, 0x6705bd02, 0x6705be02, 0x6705bf02, + 0x6705c002, 0x6705c102, 0x6705c202, 0x6705c302, 0x6705c402, 0x6705c502, 0x6705c602, 0x6705c702, + 0x6705c802, 0x6705c902, 0x6705ca02, 0x6705cb02, 0x6705cc02, 0x6705cd02, 0x6705ce02, 0x6705cf02, + 0x6705d002, 0x6705d102, 0x6705d202, 0x6705d302, 0x6705d402, 0x6705d502, 0x6705d602, 0x6705d702, + 0x6705d802, 0x6705d902, 0x6705da02, 0x6705db02, 0x6705dc02, 0x6705dd02, 0x6705de02, 0x6705df02, + 0x6705e002, 0x6705e102, 0x6705e202, 0x6705e302, 0x6705e402, 0x6705e502, 0x6705e602, 0x6705e702, + 0x6705e802, 0x6705e902, 0x6705ea02, 0x6705eb02, 0x6705ec02, 0x6705ed02, 0x6705ee02, 0x6705ef02, + 0x6705f002, 0x6705f102, 0x6705f202, 0x6705f302, 0x6705f402, 0x6705f502, 0x6705f602, 0x6705f702, + 0x6705f802, 0x6705f902, 0x6705fa02, 0x6705fb02, 0x6705fc02, 0x6705fd02, 0x6705fe02, 0x6705ff02, + 0x68050202, 0x68050302, 0x68050402, 0x68050502, 0x68050602, 0x68050702, 0x68050802, 0x68050902, + 0x68050a02, 0x68050b02, 0x68050c02, 0x68050d02, 0x68050e02, 0x68050f02, 0x68051002, 0x68051102, + 0x68051202, 0x68051302, 0x68051402, 0x68051502, 0x68051602, 0x68051702, 0x68051802, 0x68051902, + 0x68051a02, 0x68051b02, 0x68051c02, 0x68051d02, 0x68051e02, 0x68051f02, 0x68052002, 0x68052102, + 0x68052202, 0x68052302, 0x68052402, 0x68052502, 0x68052602, 0x68052702, 0x68052802, 0x68052902, + 0x68052a02, 0x68052b02, 0x68052c02, 0x68052d02, 0x68052e02, 0x68052f02, 0x68053002, 0x68053102, + 0x68053202, 0x68053302, 0x68053402, 0x68053502, 0x68053602, 0x68053702, 0x68053802, 0x68053902, + 0x68053a02, 0x68053b02, 0x68053c02, 0x68053d02, 0x68053e02, 0x68053f02, 0x68054002, 0x68054102, + 0x68054202, 0x68054302, 0x68054402, 0x68054502, 0x68054602, 0x68054702, 0x68054802, 0x68054902, + 0x68054a02, 0x68054b02, 0x68054c02, 0x68054d02, 0x68054e02, 0x68054f02, 0x68055002, 0x68055102, + 0x68055202, 0x68055302, 0x68055402, 0x68055502, 0x68055602, 0x68055702, 0x68055802, 0x68055902, + 0x68055a02, 0x68055b02, 0x68055c02, 0x68055d02, 0x68055e02, 0x68055f02, 0x68056002, 0x68056102, + 0x68056202, 0x68056302, 0x68056402, 0x68056502, 0x68056602, 0x68056702, 0x68056802, 0x68056902, + 0x68056a02, 0x68056b02, 0x68056c02, 0x68056d02, 0x68056e02, 0x68056f02, 0x68057002, 0x68057102, + 0x68057202, 0x68057302, 0x68057402, 0x68057502, 0x68057602, 0x68057702, 0x68057802, 0x68057902, + 0x68057a02, 0x68057b02, 0x68057c02, 0x68057d02, 0x68057e02, 0x68057f02, 0x68058002, 0x68058102, + 0x68058202, 0x68058302, 0x68058402, 0x68058502, 0x68058602, 0x68058702, 0x68058802, 0x68058902, + 0x68058a02, 0x68058b02, 0x68058c02, 0x68058d02, 0x68058e02, 0x68058f02, 0x68059002, 0x68059102, + 0x68059202, 0x68059302, 0x68059402, 0x68059502, 0x68059602, 0x68059702, 0x68059802, 0x68059902, + 0x68059a02, 0x68059b02, 0x68059c02, 0x68059d02, 0x68059e02, 0x68059f02, 0x6805a002, 0x6805a102, + 0x6805a202, 0x6805a302, 0x6805a402, 0x6805a502, 0x6805a602, 0x6805a702, 0x6805a802, 0x6805a902, + 0x6805aa02, 0x6805ab02, 0x6805ac02, 0x6805ad02, 0x6805ae02, 0x6805af02, 0x6805b002, 0x6805b102, + 0x6805b202, 0x6805b302, 0x6805b402, 0x6805b502, 0x6805b602, 0x6805b702, 0x6805b802, 0x6805b902, + 0x6805ba02, 0x6805bb02, 0x6805bc02, 0x6805bd02, 0x6805be02, 0x6805bf02, 0x6805c002, 0x6805c102, + 0x6805c202, 0x6805c302, 0x6805c402, 0x6805c502, 0x6805c602, 0x6805c702, 0x6805c802, 0x6805c902, + 0x6805ca02, 0x6805cb02, 0x6805cc02, 0x6805cd02, 0x6805ce02, 0x6805cf02, 0x6805d002, 0x6805d102, + 0x6805d202, 0x6805d302, 0x6805d402, 0x6805d502, 0x6805d602, 0x6805d702, 0x6805d802, 0x6805d902, + 0x6805da02, 0x6805db02, 0x6805dc02, 0x6805dd02, 0x6805de02, 0x6805df02, 0x6805e002, 0x6805e102, + 0x6805e202, 0x6805e302, 0x6805e402, 0x6805e502, 0x6805e602, 0x6805e702, 0x6805e802, 0x6805e902, + 0x6805ea02, 0x6805eb02, 0x6805ec02, 0x6805ed02, 0x6805ee02, 0x6805ef02, 0x6805f002, 0x6805f102, + 0x6805f202, 0x6805f302, 0x6805f402, 0x6805f502, 0x6805f602, 0x6805f702, 0x6805f802, 0x6805f902, + 0x6805fa02, 0x6805fb02, 0x6805fc02, 0x6805fd02, 0x6805fe02, 0x6805ff02, 0x69050202, 0x69050302, + 0x69050402, 0x69050502, 0x69050602, 0x69050702, 0x69050802, 0x69050902, 0x69050a02, 0x69050b02, + 0x69050c02, 0x69050d02, 0x69050e02, 0x69050f02, 0x69051002, 0x69051102, 0x69051202, 0x69051302, + 0x69051402, 0x69051502, 0x69051602, 0x69051702, 0x69051802, 0x69051902, 0x69051a02, 0x69051b02, + 0x69051c02, 0x69051d02, 0x69051e02, 0x69051f02, 0x69052002, 0x69052102, 0x69052202, 0x69052302, + 0x69052402, 0x69052502, 0x69052602, 0x69052702, 0x69052802, 0x69052902, 0x69052a02, 0x69052b02, + 0x69052c02, 0x69052d02, 0x69052e02, 0x69052f02, 0x69053002, 0x69053102, 0x69053202, 0x69053302, + 0x69053402, 0x69053502, 0x69053602, 0x69053702, 0x69053802, 0x69053902, 0x69053a02, 0x69053b02, + 0x69053c02, 0x69053d02, 0x69053e02, 0x69053f02, 0x69054002, 0x69054102, 0x69054202, 0x69054302, + 0x69054402, 0x69054502, 0x69054602, 0x69054702, 0x69054802, 0x69054902, 0x69054a02, 0x69054b02, + 0x69054c02, 0x69054d02, 0x69054e02, 0x69054f02, 0x69055002, 0x69055102, 0x69055202, 0x69055302, + 0x69055402, 0x69055502, 0x69055602, 0x69055702, 0x69055802, 0x69055902, 0x69055a02, 0x69055b02, + 0x69055c02, 0x69055d02, 0x69055e02, 0x69055f02, 0x69056002, 0x69056102, 0x69056202, 0x69056302, + 0x69056402, 0x69056502, 0x69056602, 0x69056702, 0x69056802, 0x69056902, 0x69056a02, 0x69056b02, + 0x69056c02, 0x69056d02, 0x69056e02, 0x69056f02, 0x69057002, 0x69057102, 0x69057202, 0x69057302, + 0x69057402, 0x69057502, 0x69057602, 0x69057702, 0x69057802, 0x69057902, 0x69057a02, 0x69057b02, + 0x69057c02, 0x69057d02, 0x69057e02, 0x69057f02, 0x69058002, 0x69058102, 0x69058202, 0x69058302, + 0x69058402, 0x69058502, 0x69058602, 0x69058702, 0x69058802, 0x69058902, 0x69058a02, 0x69058b02, + 0x69058c02, 0x69058d02, 0x69058e02, 0x69058f02, 0x69059002, 0x69059102, 0x69059202, 0x69059302, + 0x69059402, 0x69059502, 0x69059602, 0x69059702, 0x69059802, 0x69059902, 0x69059a02, 0x69059b02, + 0x69059c02, 0x69059d02, 0x69059e02, 0x69059f02, 0x6905a002, 0x6905a102, 0x6905a202, 0x6905a302, + 0x6905a402, 0x6905a502, 0x6905a602, 0x6905a702, 0x6905a802, 0x6905a902, 0x6905aa02, 0x6905ab02, + 0x6905ac02, 0x6905ad02, 0x6905ae02, 0x6905af02, 0x6905b002, 0x6905b102, 0x6905b202, 0x6905b302, + 0x6905b402, 0x6905b502, 0x6905b602, 0x6905b702, 0x6905b802, 0x6905b902, 0x6905ba02, 0x6905bb02, + 0x6905bc02, 0x6905bd02, 0x6905be02, 0x6905bf02, 0x6905c002, 0x6905c102, 0x6905c202, 0x6905c302, + 0x6905c402, 0x6905c502, 0x6905c602, 0x6905c702, 0x6905c802, 0x6905c902, 0x6905ca02, 0x6905cb02, + 0x6905cc02, 0x6905cd02, 0x6905ce02, 0x6905cf02, 0x6905d002, 0x6905d102, 0x6905d202, 0x6905d302, + 0x6905d402, 0x6905d502, 0x6905d602, 0x6905d702, 0x6905d802, 0x6905d902, 0x6905da02, 0x6905db02, + 0x6905dc02, 0x6905dd02, 0x6905de02, 0x6905df02, 0x6905e002, 0x6905e102, 0x6905e202, 0x6905e302, + 0x6905e402, 0x6905e502, 0x6905e602, 0x6905e702, 0x6905e802, 0x6905e902, 0x6905ea02, 0x6905eb02, + 0x6905ec02, 0x6905ed02, 0x6905ee02, 0x6905ef02, 0x6905f002, 0x6905f102, 0x6905f202, 0x6905f302, + 0x6905f402, 0x6905f502, 0x6905f602, 0x6905f702, 0x6905f802, 0x6905f902, 0x6905fa02, 0x6905fb02, + 0x6905fc02, 0x6905fd02, 0x6905fe02, 0x6905ff02, 0x6a050202, 0x6a050302, 0x6a050402, 0x6a050502, + 0x6a050602, 0x6a050702, 0x6a050802, 0x6a050902, 0x6a050a02, 0x6a050b02, 0x6a050c02, 0x6a050d02, + 0x6a050e02, 0x6a050f02, 0x6a051002, 0x6a051102, 0x6a051202, 0x6a051302, 0x6a051402, 0x6a051502, + 0x6a051602, 0x6a051702, 0x6a051802, 0x6a051902, 0x6a051a02, 0x6a051b02, 0x6a051c02, 0x6a051d02, + 0x6a051e02, 0x6a051f02, 0x6a052002, 0x6a052102, 0x6a052202, 0x6a052302, 0x6a052402, 0x6a052502, + 0x6a052602, 0x6a052702, 0x6a052802, 0x6a052902, 0x6a052a02, 0x6a052b02, 0x6a052c02, 0x6a052d02, + 0x6a052e02, 0x6a052f02, 0x6a053002, 0x6a053102, 0x6a053202, 0x6a053302, 0x6a053402, 0x6a053502, + 0x6a053602, 0x6a053702, 0x6a053802, 0x6a053902, 0x6a053a02, 0x6a053b02, 0x6a053c02, 0x6a053d02, + 0x6a053e02, 0x6a053f02, 0x6a054002, 0x6a054102, 0x6a054202, 0x6a054302, 0x6a054402, 0x6a054502, + 0x6a054602, 0x6a054702, 0x6a054802, 0x6a054902, 0x6a054a02, 0x6a054b02, 0x6a054c02, 0x6a054d02, + 0x6a054e02, 0x6a054f02, 0x6a055002, 0x6a055102, 0x6a055202, 0x6a055302, 0x6a055402, 0x6a055502, + 0x6a055602, 0x6a055702, 0x6a055802, 0x6a055902, 0x6a055a02, 0x6a055b02, 0x6a055c02, 0x6a055d02, + 0x6a055e02, 0x6a055f02, 0x6a056002, 0x6a056102, 0x6a056202, 0x6a056302, 0x6a056402, 0x6a056502, + 0x6a056602, 0x6a056702, 0x6a056802, 0x6a056902, 0x6a056a02, 0x6a056b02, 0x6a056c02, 0x6a056d02, + 0x6a056e02, 0x6a056f02, 0x6a057002, 0x6a057102, 0x6a057202, 0x6a057302, 0x6a057402, 0x6a057502, + 0x6a057602, 0x6a057702, 0x6a057802, 0x6a057902, 0x6a057a02, 0x6a057b02, 0x6a057c02, 0x6a057d02, + 0x6a057e02, 0x6a057f02, 0x6a058002, 0x6a058102, 0x6a058202, 0x6a058302, 0x6a058402, 0x6a058502, + 0x6a058602, 0x6a058702, 0x6a058802, 0x6a058902, 0x6a058a02, 0x6a058b02, 0x6a058c02, 0x6a058d02, + 0x6a058e02, 0x6a058f02, 0x6a059002, 0x6a059102, 0x6a059202, 0x6a059302, 0x6a059402, 0x6a059502, + 0x6a059602, 0x6a059702, 0x6a059802, 0x6a059902, 0x6a059a02, 0x6a059b02, 0x6a059c02, 0x6a059d02, + 0x6a059e02, 0x6a059f02, 0x6a05a002, 0x6a05a102, 0x6a05a202, 0x6a05a302, 0x6a05a402, 0x6a05a502, + 0x6a05a602, 0x6a05a702, 0x6a05a802, 0x6a05a902, 0x6a05aa02, 0x6a05ab02, 0x6a05ac02, 0x6a05ad02, + 0x6a05ae02, 0x6a05af02, 0x6a05b002, 0x6a05b102, 0x6a05b202, 0x6a05b302, 0x6a05b402, 0x6a05b502, + 0x6a05b602, 0x6a05b702, 0x6a05b802, 0x6a05b902, 0x6a05ba02, 0x6a05bb02, 0x6a05bc02, 0x6a05bd02, + 0x6a05be02, 0x6a05bf02, 0x6a05c002, 0x6a05c102, 0x6a05c202, 0x6a05c302, 0x6a05c402, 0x6a05c502, + 0x6a05c602, 0x6a05c702, 0x6a05c802, 0x6a05c902, 0x6a05ca02, 0x6a05cb02, 0x6a05cc02, 0x6a05cd02, + 0x6a05ce02, 0x6a05cf02, 0x6a05d002, 0x6a05d102, 0x6a05d202, 0x6a05d302, 0x6a05d402, 0x6a05d502, + 0x6a05d602, 0x6a05d702, 0x6a05d802, 0x6a05d902, 0x6a05da02, 0x6a05db02, 0x6a05dc02, 0x6a05dd02, + 0x6a05de02, 0x6a05df02, 0x6a05e002, 0x6a05e102, 0x6a05e202, 0x6a05e302, 0x6a05e402, 0x6a05e502, + 0x6a05e602, 0x6a05e702, 0x6a05e802, 0x6a05e902, 0x6a05ea02, 0x6a05eb02, 0x6a05ec02, 0x6a05ed02, + 0x6a05ee02, 0x6a05ef02, 0x6a05f002, 0x6a05f102, 0x6a05f202, 0x6a05f302, 0x6a05f402, 0x6a05f502, + 0x6a05f602, 0x6a05f702, 0x6a05f802, 0x6a05f902, 0x6a05fa02, 0x6a05fb02, 0x6a05fc02, 0x6a05fd02, + 0x6a05fe02, 0x6a05ff02, 0x6b050202, 0x6b050302, 0x6b050402, 0x6b050502, 0x6b050602, 0x6b050702, + 0x6b050802, 0x6b050902, 0x6b050a02, 0x6b050b02, 0x6b050c02, 0x6b050d02, 0x6b050e02, 0x6b050f02, + 0x6b051002, 0x6b051102, 0x6b051202, 0x6b051302, 0x6b051402, 0x6b051502, 0x6b051602, 0x6b051702, + 0x6b051802, 0x6b051902, 0x6b051a02, 0x6b051b02, 0x6b051c02, 0x6b051d02, 0x6b051e02, 0x6b051f02, + 0x6b052002, 0x6b052102, 0x6b052202, 0x6b052302, 0x6b052402, 0x6b052502, 0x6b052602, 0x6b052702, + 0x6b052802, 0x6b052902, 0x6b052a02, 0x6b052b02, 0x6b052c02, 0x6b052d02, 0x6b052e02, 0x6b052f02, + 0x6b053002, 0x6b053102, 0x6b053202, 0x6b053302, 0x6b053402, 0x6b053502, 0x6b053602, 0x6b053702, + 0x6b053802, 0x6b053902, 0x6b053a02, 0x6b053b02, 0x6b053c02, 0x6b053d02, 0x6b053e02, 0x6b053f02, + 0x6b054002, 0x6b054102, 0x6b054202, 0x6b054302, 0x6b054402, 0x6b054502, 0x6b054602, 0x6b054702, + 0x6b054802, 0x6b054902, 0x6b054a02, 0x6b054b02, 0x6b054c02, 0x6b054d02, 0x6b054e02, 0x6b054f02, + 0x6b055002, 0x6b055102, 0x6b055202, 0x6b055302, 0x6b055402, 0x6b055502, 0x6b055602, 0x6b055702, + 0x6b055802, 0x6b055902, 0x6b055a02, 0x6b055b02, 0x6b055c02, 0x6b055d02, 0x6b055e02, 0x6b055f02, + 0x6b056002, 0x6b056102, 0x6b056202, 0x6b056302, 0x6b056402, 0x6b056502, 0x6b056602, 0x6b056702, + 0x6b056802, 0x6b056902, 0x6b056a02, 0x6b056b02, 0x6b056c02, 0x6b056d02, 0x6b056e02, 0x6b056f02, + 0x6b057002, 0x6b057102, 0x6b057202, 0x6b057302, 0x6b057402, 0x6b057502, 0x6b057602, 0x6b057702, + 0x6b057802, 0x6b057902, 0x6b057a02, 0x6b057b02, 0x6b057c02, 0x6b057d02, 0x6b057e02, 0x6b057f02, + 0x6b058002, 0x6b058102, 0x6b058202, 0x6b058302, 0x6b058402, 0x6b058502, 0x6b058602, 0x6b058702, + 0x6b058802, 0x6b058902, 0x6b058a02, 0x6b058b02, 0x6b058c02, 0x6b058d02, 0x6b058e02, 0x6b058f02, + 0x6b059002, 0x6b059102, 0x6b059202, 0x6b059302, 0x6b059402, 0x6b059502, 0x6b059602, 0x6b059702, + 0x6b059802, 0x6b059902, 0x6b059a02, 0x6b059b02, 0x6b059c02, 0x6b059d02, 0x6b059e02, 0x6b059f02, + 0x6b05a002, 0x6b05a102, 0x6b05a202, 0x6b05a302, 0x6b05a402, 0x6b05a502, 0x6b05a602, 0x6b05a702, + 0x6b05a802, 0x6b05a902, 0x6b05aa02, 0x6b05ab02, 0x6b05ac02, 0x6b05ad02, 0x6b05ae02, 0x6b05af02, + 0x6b05b002, 0x6b05b102, 0x6b05b202, 0x6b05b302, 0x6b05b402, 0x6b05b502, 0x6b05b602, 0x6b05b702, + 0x6b05b802, 0x6b05b902, 0x6b05ba02, 0x6b05bb02, 0x6b05bc02, 0x6b05bd02, 0x6b05be02, 0x6b05bf02, + 0x6b05c002, 0x6b05c102, 0x6b05c202, 0x6b05c302, 0x6b05c402, 0x6b05c502, 0x6b05c602, 0x6b05c702, + 0x6b05c802, 0x6b05c902, 0x6b05ca02, 0x6b05cb02, 0x6b05cc02, 0x6b05cd02, 0x6b05ce02, 0x6b05cf02, + 0x6b05d002, 0x6b05d102, 0x6b05d202, 0x6b05d302, 0x6b05d402, 0x6b05d502, 0x6b05d602, 0x6b05d702, + 0x6b05d802, 0x6b05d902, 0x6b05da02, 0x6b05db02, 0x6b05dc02, 0x6b05dd02, 0x6b05de02, 0x6b05df02, + 0x6b05e002, 0x6b05e102, 0x6b05e202, 0x6b05e302, 0x6b05e402, 0x6b05e502, 0x6b05e602, 0x6b05e702, + 0x6b05e802, 0x6b05e902, 0x6b05ea02, 0x6b05eb02, 0x6b05ec02, 0x6b05ed02, 0x6b05ee02, 0x6b05ef02, + 0x6b05f002, 0x6b05f102, 0x6b05f202, 0x6b05f302, 0x6b05f402, 0x6b05f502, 0x6b05f602, 0x6b05f702, + 0x6b05f802, 0x6b05f902, 0x6b05fa02, 0x6b05fb02, 0x6b05fc02, 0x6b05fd02, 0x6b05fe02, 0x6b05ff02, + 0x6c050202, 0x6c050302, 0x6c050402, 0x6c050502, 0x6c050602, 0x6c050702, 0x6c050802, 0x6c050902, + 0x6c050a02, 0x6c050b02, 0x6c050c02, 0x6c050d02, 0x6c050e02, 0x6c050f02, 0x6c051002, 0x6c051102, + 0x6c051202, 0x6c051302, 0x6c051402, 0x6c051502, 0x6c051602, 0x6c051702, 0x6c051802, 0x6c051902, + 0x6c051a02, 0x6c051b02, 0x6c051c02, 0x6c051d02, 0x6c051e02, 0x6c051f02, 0x6c052002, 0x6c052102, + 0x6c052202, 0x6c052302, 0x6c052402, 0x6c052502, 0x6c052602, 0x6c052702, 0x6c052802, 0x6c052902, + 0x6c052a02, 0x6c052b02, 0x6c052c02, 0x6c052d02, 0x6c052e02, 0x6c052f02, 0x6c053002, 0x6c053102, + 0x6c053202, 0x6c053302, 0x6c053402, 0x6c053502, 0x6c053602, 0x6c053702, 0x6c053802, 0x6c053902, + 0x6c053a02, 0x6c053b02, 0x6c053c02, 0x6c053d02, 0x6c053e02, 0x6c053f02, 0x6c054002, 0x6c054102, + 0x6c054202, 0x6c054302, 0x6c054402, 0x6c054502, 0x6c054602, 0x6c054702, 0x6c054802, 0x6c054902, + 0x6c054a02, 0x6c054b02, 0x6c054c02, 0x6c054d02, 0x6c054e02, 0x6c054f02, 0x6c055002, 0x6c055102, + 0x6c055202, 0x6c055302, 0x6c055402, 0x6c055502, 0x6c055602, 0x6c055702, 0x6c055802, 0x6c055902, + 0x6c055a02, 0x6c055b02, 0x6c055c02, 0x6c055d02, 0x6c055e02, 0x6c055f02, 0x6c056002, 0x6c056102, + 0x6c056202, 0x6c056302, 0x6c056402, 0x6c056502, 0x6c056602, 0x6c056702, 0x6c056802, 0x6c056902, + 0x6c056a02, 0x6c056b02, 0x6c056c02, 0x6c056d02, 0x6c056e02, 0x6c056f02, 0x6c057002, 0x6c057102, + 0x6c057202, 0x6c057302, 0x6c057402, 0x6c057502, 0x6c057602, 0x6c057702, 0x6c057802, 0x6c057902, + 0x6c057a02, 0x6c057b02, 0x6c057c02, 0x6c057d02, 0x6c057e02, 0x6c057f02, 0x6c058002, 0x6c058102, + 0x6c058202, 0x6c058302, 0x6c058402, 0x6c058502, 0x6c058602, 0x6c058702, 0x6c058802, 0x6c058902, + 0x6c058a02, 0x6c058b02, 0x6c058c02, 0x6c058d02, 0x6c058e02, 0x6c058f02, 0x6c059002, 0x6c059102, + 0x6c059202, 0x6c059302, 0x6c059402, 0x6c059502, 0x6c059602, 0x6c059702, 0x6c059802, 0x6c059902, + 0x6c059a02, 0x6c059b02, 0x6c059c02, 0x6c059d02, 0x6c059e02, 0x6c059f02, 0x6c05a002, 0x6c05a102, + 0x6c05a202, 0x6c05a302, 0x6c05a402, 0x6c05a502, 0x6c05a602, 0x6c05a702, 0x6c05a802, 0x6c05a902, + 0x6c05aa02, 0x6c05ab02, 0x6c05ac02, 0x6c05ad02, 0x6c05ae02, 0x6c05af02, 0x6c05b002, 0x6c05b102, + 0x6c05b202, 0x6c05b302, 0x6c05b402, 0x6c05b502, 0x6c05b602, 0x6c05b702, 0x6c05b802, 0x6c05b902, + 0x6c05ba02, 0x6c05bb02, 0x6c05bc02, 0x6c05bd02, 0x6c05be02, 0x6c05bf02, 0x6c05c002, 0x6c05c102, + 0x6c05c202, 0x6c05c302, 0x6c05c402, 0x6c05c502, 0x6c05c602, 0x6c05c702, 0x6c05c802, 0x6c05c902, + 0x6c05ca02, 0x6c05cb02, 0x6c05cc02, 0x6c05cd02, 0x6c05ce02, 0x6c05cf02, 0x6c05d002, 0x6c05d102, + 0x6c05d202, 0x6c05d302, 0x6c05d402, 0x6c05d502, 0x6c05d602, 0x6c05d702, 0x6c05d802, 0x6c05d902, + 0x6c05da02, 0x6c05db02, 0x6c05dc02, 0x6c05dd02, 0x6c05de02, 0x6c05df02, 0x6c05e002, 0x6c05e102, + 0x6c05e202, 0x6c05e302, 0x6c05e402, 0x6c05e502, 0x6c05e602, 0x6c05e702, 0x6c05e802, 0x6c05e902, + 0x6c05ea02, 0x6c05eb02, 0x6c05ec02, 0x6c05ed02, 0x6c05ee02, 0x6c05ef02, 0x6c05f002, 0x6c05f102, + 0x6c05f202, 0x6c05f302, 0x6c05f402, 0x6c05f502, 0x6c05f602, 0x6c05f702, 0x6c05f802, 0x6c05f902, + 0x6c05fa02, 0x6c05fb02, 0x6c05fc02, 0x6c05fd02, 0x6c05fe02, 0x6c05ff02, 0x6d050202, 0x6d050302, + 0x6d050402, 0x6d050502, 0x6d050602, 0x6d050702, 0x6d050802, 0x6d050902, 0x6d050a02, 0x6d050b02, + 0x6d050c02, 0x6d050d02, 0x6d050e02, 0x6d050f02, 0x6d051002, 0x6d051102, 0x6d051202, 0x6d051302, + 0x6d051402, 0x6d051502, 0x6d051602, 0x6d051702, 0x6d051802, 0x6d051902, 0x6d051a02, 0x6d051b02, + 0x6d051c02, 0x6d051d02, 0x6d051e02, 0x6d051f02, 0x6d052002, 0x6d052102, 0x6d052202, 0x6d052302, + 0x6d052402, 0x6d052502, 0x6d052602, 0x6d052702, 0x6d052802, 0x6d052902, 0x6d052a02, 0x6d052b02, + 0x6d052c02, 0x6d052d02, 0x6d052e02, 0x6d052f02, 0x6d053002, 0x6d053102, 0x6d053202, 0x6d053302, + 0x6d053402, 0x6d053502, 0x6d053602, 0x6d053702, 0x6d053802, 0x6d053902, 0x6d053a02, 0x6d053b02, + 0x6d053c02, 0x6d053d02, 0x6d053e02, 0x6d053f02, 0x6d054002, 0x6d054102, 0x6d054202, 0x6d054302, + 0x6d054402, 0x6d054502, 0x6d054602, 0x6d054702, 0x6d054802, 0x6d054902, 0x6d054a02, 0x6d054b02, + 0x6d054c02, 0x6d054d02, 0x6d054e02, 0x6d054f02, 0x6d055002, 0x6d055102, 0x6d055202, 0x6d055302, + 0x6d055402, 0x6d055502, 0x6d055602, 0x6d055702, 0x6d055802, 0x6d055902, 0x6d055a02, 0x6d055b02, + 0x6d055c02, 0x6d055d02, 0x6d055e02, 0x6d055f02, 0x6d056002, 0x6d056102, 0x6d056202, 0x6d056302, + 0x6d056402, 0x6d056502, 0x6d056602, 0x6d056702, 0x6d056802, 0x6d056902, 0x6d056a02, 0x6d056b02, + 0x6d056c02, 0x6d056d02, 0x6d056e02, 0x6d056f02, 0x6d057002, 0x6d057102, 0x6d057202, 0x6d057302, + 0x6d057402, 0x6d057502, 0x6d057602, 0x6d057702, 0x6d057802, 0x6d057902, 0x6d057a02, 0x6d057b02, + 0x6d057c02, 0x6d057d02, 0x6d057e02, 0x6d057f02, 0x6d058002, 0x6d058102, 0x6d058202, 0x6d058302, + 0x6d058402, 0x6d058502, 0x6d058602, 0x6d058702, 0x6d058802, 0x6d058902, 0x6d058a02, 0x6d058b02, + 0x6d058c02, 0x6d058d02, 0x6d058e02, 0x6d058f02, 0x6d059002, 0x6d059102, 0x6d059202, 0x6d059302, + 0x6d059402, 0x6d059502, 0x6d059602, 0x6d059702, 0x6d059802, 0x6d059902, 0x6d059a02, 0x6d059b02, + 0x6d059c02, 0x6d059d02, 0x6d059e02, 0x6d059f02, 0x6d05a002, 0x6d05a102, 0x6d05a202, 0x6d05a302, + 0x6d05a402, 0x6d05a502, 0x6d05a602, 0x6d05a702, 0x6d05a802, 0x6d05a902, 0x6d05aa02, 0x6d05ab02, + 0x6d05ac02, 0x6d05ad02, 0x6d05ae02, 0x6d05af02, 0x6d05b002, 0x6d05b102, 0x6d05b202, 0x6d05b302, + 0x6d05b402, 0x6d05b502, 0x6d05b602, 0x6d05b702, 0x6d05b802, 0x6d05b902, 0x6d05ba02, 0x6d05bb02, + 0x6d05bc02, 0x6d05bd02, 0x6d05be02, 0x6d05bf02, 0x6d05c002, 0x6d05c102, 0x6d05c202, 0x6d05c302, + 0x6d05c402, 0x6d05c502, 0x6d05c602, 0x6d05c702, 0x6d05c802, 0x6d05c902, 0x6d05ca02, 0x6d05cb02, + 0x6d05cc02, 0x6d05cd02, 0x6d05ce02, 0x6d05cf02, 0x6d05d002, 0x6d05d102, 0x6d05d202, 0x6d05d302, + 0x6d05d402, 0x6d05d502, 0x6d05d602, 0x6d05d702, 0x6d05d802, 0x6d05d902, 0x6d05da02, 0x6d05db02, + 0x6d05dc02, 0x6d05dd02, 0x6d05de02, 0x6d05df02, 0x6d05e002, 0x6d05e102, 0x6d05e202, 0x6d05e302, + 0x6d05e402, 0x6d05e502, 0x6d05e602, 0x6d05e702, 0x6d05e802, 0x6d05e902, 0x6d05ea02, 0x6d05eb02, + 0x6d05ec02, 0x6d05ed02, 0x6d05ee02, 0x6d05ef02, 0x6d05f002, 0x6d05f102, 0x6d05f202, 0x6d05f302, + 0x6d05f402, 0x6d05f502, 0x6d05f602, 0x6d05f702, 0x6d05f802, 0x6d05f902, 0x6d05fa02, 0x6d05fb02, + 0x6d05fc02, 0x6d05fd02, 0x6d05fe02, 0x6d05ff02, 0x6e050202, 0x6e050302, 0x6e050402, 0x6e050502, + 0x6e050602, 0x6e050702, 0x6e050802, 0x6e050902, 0x6e050a02, 0x6e050b02, 0x6e050c02, 0x6e050d02, + 0x6e050e02, 0x6e050f02, 0x6e051002, 0x6e051102, 0x6e051202, 0x6e051302, 0x6e051402, 0x6e051502, + 0x6e051602, 0x6e051702, 0x6e051802, 0x6e051902, 0x6e051a02, 0x6e051b02, 0x6e051c02, 0x6e051d02, + 0x6e051e02, 0x6e051f02, 0x6e052002, 0x6e052102, 0x6e052202, 0x6e052302, 0x6e052402, 0x6e052502, + 0x6e052602, 0x6e052702, 0x6e052802, 0x6e052902, 0x6e052a02, 0x6e052b02, 0x6e052c02, 0x6e052d02, + 0x6e052e02, 0x6e052f02, 0x6e053002, 0x6e053102, 0x6e053202, 0x6e053302, 0x6e053402, 0x6e053502, + 0x6e053602, 0x6e053702, 0x6e053802, 0x6e053902, 0x6e053a02, 0x6e053b02, 0x6e053c02, 0x6e053d02, + 0x6e053e02, 0x6e053f02, 0x6e054002, 0x6e054102, 0x6e054202, 0x6e054302, 0x6e054402, 0x6e054502, + 0x6e054602, 0x6e054702, 0x6e054802, 0x6e054902, 0x6e054a02, 0x6e054b02, 0x6e054c02, 0x6e054d02, + 0x6e054e02, 0x6e054f02, 0x6e055002, 0x6e055102, 0x6e055202, 0x6e055302, 0x6e055402, 0x6e055502, + 0x6e055602, 0x6e055702, 0x6e055802, 0x6e055902, 0x6e055a02, 0x6e055b02, 0x6e055c02, 0x6e055d02, + 0x6e055e02, 0x6e055f02, 0x6e056002, 0x6e056102, 0x6e056202, 0x6e056302, 0x6e056402, 0x6e056502, + 0x6e056602, 0x6e056702, 0x6e056802, 0x6e056902, 0x6e056a02, 0x6e056b02, 0x6e056c02, 0x6e056d02, + 0x6e056e02, 0x6e056f02, 0x6e057002, 0x6e057102, 0x6e057202, 0x6e057302, 0x6e057402, 0x6e057502, + 0x6e057602, 0x6e057702, 0x6e057802, 0x6e057902, 0x6e057a02, 0x6e057b02, 0x6e057c02, 0x6e057d02, + 0x6e057e02, 0x6e057f02, 0x6e058002, 0x6e058102, 0x6e058202, 0x6e058302, 0x6e058402, 0x6e058502, + 0x6e058602, 0x6e058702, 0x6e058802, 0x6e058902, 0x6e058a02, 0x6e058b02, 0x6e058c02, 0x6e058d02, + 0x6e058e02, 0x6e058f02, 0x6e059002, 0x6e059102, 0x6e059202, 0x6e059302, 0x6e059402, 0x6e059502, + 0x6e059602, 0x6e059702, 0x6e059802, 0x6e059902, 0x6e059a02, 0x6e059b02, 0x6e059c02, 0x6e059d02, + 0x6e059e02, 0x6e059f02, 0x6e05a002, 0x6e05a102, 0x6e05a202, 0x6e05a302, 0x6e05a402, 0x6e05a502, + 0x6e05a602, 0x6e05a702, 0x6e05a802, 0x6e05a902, 0x6e05aa02, 0x6e05ab02, 0x6e05ac02, 0x6e05ad02, + 0x6e05ae02, 0x6e05af02, 0x6e05b002, 0x6e05b102, 0x6e05b202, 0x6e05b302, 0x6e05b402, 0x6e05b502, + 0x6e05b602, 0x6e05b702, 0x6e05b802, 0x6e05b902, 0x6e05ba02, 0x6e05bb02, 0x6e05bc02, 0x6e05bd02, + 0x6e05be02, 0x6e05bf02, 0x6e05c002, 0x6e05c102, 0x6e05c202, 0x6e05c302, 0x6e05c402, 0x6e05c502, + 0x6e05c602, 0x6e05c702, 0x6e05c802, 0x6e05c902, 0x6e05ca02, 0x6e05cb02, 0x6e05cc02, 0x6e05cd02, + 0x6e05ce02, 0x6e05cf02, 0x6e05d002, 0x6e05d102, 0x6e05d202, 0x6e05d302, 0x6e05d402, 0x6e05d502, + 0x6e05d602, 0x6e05d702, 0x6e05d802, 0x6e05d902, 0x6e05da02, 0x6e05db02, 0x6e05dc02, 0x6e05dd02, + 0x6e05de02, 0x6e05df02, 0x6e05e002, 0x6e05e102, 0x6e05e202, 0x6e05e302, 0x6e05e402, 0x6e05e502, + 0x6e05e602, 0x6e05e702, 0x6e05e802, 0x6e05e902, 0x6e05ea02, 0x6e05eb02, 0x6e05ec02, 0x6e05ed02, + 0x6e05ee02, 0x6e05ef02, 0x6e05f002, 0x6e05f102, 0x6e05f202, 0x6e05f302, 0x6e05f402, 0x6e05f502, + 0x6e05f602, 0x6e05f702, 0x6e05f802, 0x6e05f902, 0x6e05fa02, 0x6e05fb02, 0x6e05fc02, 0x6e05fd02, + 0x6e05fe02, 0x6e05ff02, 0x6f050202, 0x6f050302, 0x6f050402, 0x6f050502, 0x6f050602, 0x6f050702, + 0x6f050802, 0x6f050902, 0x6f050a02, 0x6f050b02, 0x6f050c02, 0x6f050d02, 0x6f050e02, 0x6f050f02, + 0x6f051002, 0x6f051102, 0x6f051202, 0x6f051302, 0x6f051402, 0x6f051502, 0x6f051602, 0x6f051702, + 0x6f051802, 0x6f051902, 0x6f051a02, 0x6f051b02, 0x6f051c02, 0x6f051d02, 0x6f051e02, 0x6f051f02, + 0x6f052002, 0x6f052102, 0x6f052202, 0x6f052302, 0x6f052402, 0x6f052502, 0x6f052602, 0x6f052702, + 0x6f052802, 0x6f052902, 0x6f052a02, 0x6f052b02, 0x6f052c02, 0x6f052d02, 0x6f052e02, 0x6f052f02, + 0x6f053002, 0x6f053102, 0x6f053202, 0x6f053302, 0x6f053402, 0x6f053502, 0x6f053602, 0x6f053702, + 0x6f053802, 0x6f053902, 0x6f053a02, 0x6f053b02, 0x6f053c02, 0x6f053d02, 0x6f053e02, 0x6f053f02, + 0x6f054002, 0x6f054102, 0x6f054202, 0x6f054302, 0x6f054402, 0x6f054502, 0x6f054602, 0x6f054702, + 0x6f054802, 0x6f054902, 0x6f054a02, 0x6f054b02, 0x6f054c02, 0x6f054d02, 0x6f054e02, 0x6f054f02, + 0x6f055002, 0x6f055102, 0x6f055202, 0x6f055302, 0x6f055402, 0x6f055502, 0x6f055602, 0x6f055702, + 0x6f055802, 0x6f055902, 0x6f055a02, 0x6f055b02, 0x6f055c02, 0x6f055d02, 0x6f055e02, 0x6f055f02, + 0x6f056002, 0x6f056102, 0x6f056202, 0x6f056302, 0x6f056402, 0x6f056502, 0x6f056602, 0x6f056702, + 0x6f056802, 0x6f056902, 0x6f056a02, 0x6f056b02, 0x6f056c02, 0x6f056d02, 0x6f056e02, 0x6f056f02, + 0x6f057002, 0x6f057102, 0x6f057202, 0x6f057302, 0x6f057402, 0x6f057502, 0x6f057602, 0x6f057702, + 0x6f057802, 0x6f057902, 0x6f057a02, 0x6f057b02, 0x6f057c02, 0x6f057d02, 0x6f057e02, 0x6f057f02, + 0x6f058002, 0x6f058102, 0x6f058202, 0x6f058302, 0x6f058402, 0x6f058502, 0x6f058602, 0x6f058702, + 0x6f058802, 0x6f058902, 0x6f058a02, 0x6f058b02, 0x6f058c02, 0x6f058d02, 0x6f058e02, 0x6f058f02, + 0x6f059002, 0x6f059102, 0x6f059202, 0x6f059302, 0x6f059402, 0x6f059502, 0x6f059602, 0x6f059702, + 0x6f059802, 0x6f059902, 0x6f059a02, 0x6f059b02, 0x6f059c02, 0x6f059d02, 0x6f059e02, 0x6f059f02, + 0x6f05a002, 0x6f05a102, 0x6f05a202, 0x6f05a302, 0x6f05a402, 0x6f05a502, 0x6f05a602, 0x6f05a702, + 0x6f05a802, 0x6f05a902, 0x6f05aa02, 0x6f05ab02, 0x6f05ac02, 0x6f05ad02, 0x6f05ae02, 0x6f05af02, + 0x6f05b002, 0x6f05b102, 0x6f05b202, 0x6f05b302, 0x6f05b402, 0x6f05b502, 0x6f05b602, 0x6f05b702, + 0x6f05b802, 0x6f05b902, 0x6f05ba02, 0x6f05bb02, 0x6f05bc02, 0x6f05bd02, 0x6f05be02, 0x6f05bf02, + 0x6f05c002, 0x6f05c102, 0x6f05c202, 0x6f05c302, 0x6f05c402, 0x6f05c502, 0x6f05c602, 0x6f05c702, + 0x6f05c802, 0x6f05c902, 0x6f05ca02, 0x6f05cb02, 0x6f05cc02, 0x6f05cd02, 0x6f05ce02, 0x6f05cf02, + 0x6f05d002, 0x6f05d102, 0x6f05d202, 0x6f05d302, 0x6f05d402, 0x6f05d502, 0x6f05d602, 0x6f05d702, + 0x6f05d802, 0x6f05d902, 0x6f05da02, 0x6f05db02, 0x6f05dc02, 0x6f05dd02, 0x6f05de02, 0x6f05df02, + 0x6f05e002, 0x6f05e102, 0x6f05e202, 0x6f05e302, 0x6f05e402, 0x6f05e502, 0x6f05e602, 0x6f05e702, + 0x6f05e802, 0x6f05e902, 0x6f05ea02, 0x6f05eb02, 0x6f05ec02, 0x6f05ed02, 0x6f05ee02, 0x6f05ef02, + 0x6f05f002, 0x6f05f102, 0x6f05f202, 0x6f05f302, 0x6f05f402, 0x6f05f502, 0x6f05f602, 0x6f05f702, + 0x6f05f802, 0x6f05f902, 0x6f05fa02, 0x6f05fb02, 0x6f05fc02, 0x6f05fd02, 0x6f05fe02, 0x6f05ff02, + 0x70050202, 0x70050302, 0x70050402, 0x70050502, 0x70050602, 0x70050702, 0x70050802, 0x70050902, + 0x70050a02, 0x70050b02, 0x70050c02, 0x70050d02, 0x70050e02, 0x70050f02, 0x70051002, 0x70051102, + 0x70051202, 0x70051302, 0x70051402, 0x70051502, 0x70051602, 0x70051702, 0x70051802, 0x70051902, + 0x70051a02, 0x70051b02, 0x70051c02, 0x70051d02, 0x70051e02, 0x70051f02, 0x70052002, 0x70052102, + 0x70052202, 0x70052302, 0x70052402, 0x70052502, 0x70052602, 0x70052702, 0x70052802, 0x70052902, + 0x70052a02, 0x70052b02, 0x70052c02, 0x70052d02, 0x70052e02, 0x70052f02, 0x70053002, 0x70053102, + 0x70053202, 0x70053302, 0x70053402, 0x70053502, 0x70053602, 0x70053702, 0x70053802, 0x70053902, + 0x70053a02, 0x70053b02, 0x70053c02, 0x70053d02, 0x70053e02, 0x70053f02, 0x70054002, 0x70054102, + 0x70054202, 0x70054302, 0x70054402, 0x70054502, 0x70054602, 0x70054702, 0x70054802, 0x70054902, + 0x70054a02, 0x70054b02, 0x70054c02, 0x70054d02, 0x70054e02, 0x70054f02, 0x70055002, 0x70055102, + 0x70055202, 0x70055302, 0x70055402, 0x70055502, 0x70055602, 0x70055702, 0x70055802, 0x70055902, + 0x70055a02, 0x70055b02, 0x70055c02, 0x70055d02, 0x70055e02, 0x70055f02, 0x70056002, 0x70056102, + 0x70056202, 0x70056302, 0x70056402, 0x70056502, 0x70056602, 0x70056702, 0x70056802, 0x70056902, + 0x70056a02, 0x70056b02, 0x70056c02, 0x70056d02, 0x70056e02, 0x70056f02, 0x70057002, 0x70057102, + 0x70057202, 0x70057302, 0x70057402, 0x70057502, 0x70057602, 0x70057702, 0x70057802, 0x70057902, + 0x70057a02, 0x70057b02, 0x70057c02, 0x70057d02, 0x70057e02, 0x70057f02, 0x70058002, 0x70058102, + 0x70058202, 0x70058302, 0x70058402, 0x70058502, 0x70058602, 0x70058702, 0x70058802, 0x70058902, + 0x70058a02, 0x70058b02, 0x70058c02, 0x70058d02, 0x70058e02, 0x70058f02, 0x70059002, 0x70059102, + 0x70059202, 0x70059302, 0x70059402, 0x70059502, 0x70059602, 0x70059702, 0x70059802, 0x70059902, + 0x70059a02, 0x70059b02, 0x70059c02, 0x70059d02, 0x70059e02, 0x70059f02, 0x7005a002, 0x7005a102, + 0x7005a202, 0x7005a302, 0x7005a402, 0x7005a502, 0x7005a602, 0x7005a702, 0x7005a802, 0x7005a902, + 0x7005aa02, 0x7005ab02, 0x7005ac02, 0x7005ad02, 0x7005ae02, 0x7005af02, 0x7005b002, 0x7005b102, + 0x7005b202, 0x7005b302, 0x7005b402, 0x7005b502, 0x7005b602, 0x7005b702, 0x7005b802, 0x7005b902, + 0x7005ba02, 0x7005bb02, 0x7005bc02, 0x7005bd02, 0x7005be02, 0x7005bf02, 0x7005c002, 0x7005c102, + 0x7005c202, 0x7005c302, 0x7005c402, 0x7005c502, 0x7005c602, 0x7005c702, 0x7005c802, 0x7005c902, + 0x7005ca02, 0x7005cb02, 0x7005cc02, 0x7005cd02, 0x7005ce02, 0x7005cf02, 0x7005d002, 0x7005d102, + 0x7005d202, 0x7005d302, 0x7005d402, 0x7005d502, 0x7005d602, 0x7005d702, 0x7005d802, 0x7005d902, + 0x7005da02, 0x7005db02, 0x7005dc02, 0x7005dd02, 0x7005de02, 0x7005df02, 0x7005e002, 0x7005e102, + 0x7005e202, 0x7005e302, 0x7005e402, 0x7005e502, 0x7005e602, 0x7005e702, 0x7005e802, 0x7005e902, + 0x7005ea02, 0x7005eb02, 0x7005ec02, 0x7005ed02, 0x7005ee02, 0x7005ef02, 0x7005f002, 0x7005f102, + 0x7005f202, 0x7005f302, 0x7005f402, 0x7005f502, 0x7005f602, 0x7005f702, 0x7005f802, 0x7005f902, + 0x7005fa02, 0x7005fb02, 0x7005fc02, 0x7005fd02, 0x7005fe02, 0x7005ff02, 0x71050202, 0x71050302, + 0x71050402, 0x71050502, 0x71050602, 0x71050702, 0x71050802, 0x71050902, 0x71050a02, 0x71050b02, + 0x71050c02, 0x71050d02, 0x71050e02, 0x71050f02, 0x71051002, 0x71051102, 0x71051202, 0x71051302, + 0x71051402, 0x71051502, 0x71051602, 0x71051702, 0x71051802, 0x71051902, 0x71051a02, 0x71051b02, + 0x71051c02, 0x71051d02, 0x71051e02, 0x71051f02, 0x71052002, 0x71052102, 0x71052202, 0x71052302, + 0x71052402, 0x71052502, 0x71052602, 0x71052702, 0x71052802, 0x71052902, 0x71052a02, 0x71052b02, + 0x71052c02, 0x71052d02, 0x71052e02, 0x71052f02, 0x71053002, 0x71053102, 0x71053202, 0x71053302, + 0x71053402, 0x71053502, 0x71053602, 0x71053702, 0x71053802, 0x71053902, 0x71053a02, 0x71053b02, + 0x71053c02, 0x71053d02, 0x71053e02, 0x71053f02, 0x71054002, 0x71054102, 0x71054202, 0x71054302, + 0x71054402, 0x71054502, 0x71054602, 0x71054702, 0x71054802, 0x71054902, 0x71054a02, 0x71054b02, + 0x71054c02, 0x71054d02, 0x71054e02, 0x71054f02, 0x71055002, 0x71055102, 0x71055202, 0x71055302, + 0x71055402, 0x71055502, 0x71055602, 0x71055702, 0x71055802, 0x71055902, 0x71055a02, 0x71055b02, + 0x71055c02, 0x71055d02, 0x71055e02, 0x71055f02, 0x71056002, 0x71056102, 0x71056202, 0x71056302, + 0x71056402, 0x71056502, 0x71056602, 0x71056702, 0x71056802, 0x71056902, 0x71056a02, 0x71056b02, + 0x71056c02, 0x71056d02, 0x71056e02, 0x71056f02, 0x71057002, 0x71057102, 0x71057202, 0x71057302, + 0x71057402, 0x71057502, 0x71057602, 0x71057702, 0x71057802, 0x71057902, 0x71057a02, 0x71057b02, + 0x71057c02, 0x71057d02, 0x71057e02, 0x71057f02, 0x71058002, 0x71058102, 0x71058202, 0x71058302, + 0x71058402, 0x71058502, 0x71058602, 0x71058702, 0x71058802, 0x71058902, 0x71058a02, 0x71058b02, + 0x71058c02, 0x71058d02, 0x71058e02, 0x71058f02, 0x71059002, 0x71059102, 0x71059202, 0x71059302, + 0x71059402, 0x71059502, 0x71059602, 0x71059702, 0x71059802, 0x71059902, 0x71059a02, 0x71059b02, + 0x71059c02, 0x71059d02, 0x71059e02, 0x71059f02, 0x7105a002, 0x7105a102, 0x7105a202, 0x7105a302, + 0x7105a402, 0x7105a502, 0x7105a602, 0x7105a702, 0x7105a802, 0x7105a902, 0x7105aa02, 0x7105ab02, + 0x7105ac02, 0x7105ad02, 0x7105ae02, 0x7105af02, 0x7105b002, 0x7105b102, 0x7105b202, 0x7105b302, + 0x7105b402, 0x7105b502, 0x7105b602, 0x7105b702, 0x7105b802, 0x7105b902, 0x7105ba02, 0x7105bb02, + 0x7105bc02, 0x7105bd02, 0x7105be02, 0x7105bf02, 0x7105c002, 0x7105c102, 0x7105c202, 0x7105c302, + 0x7105c402, 0x7105c502, 0x7105c602, 0x7105c702, 0x7105c802, 0x7105c902, 0x7105ca02, 0x7105cb02, + 0x7105cc02, 0x7105cd02, 0x7105ce02, 0x7105cf02, 0x7105d002, 0x7105d102, 0x7105d202, 0x7105d302, + 0x7105d402, 0x7105d502, 0x7105d602, 0x7105d702, 0x7105d802, 0x7105d902, 0x7105da02, 0x7105db02, + 0x7105dc02, 0x7105dd02, 0x7105de02, 0x7105df02, 0x7105e002, 0x7105e102, 0x7105e202, 0x7105e302, + 0x7105e402, 0x7105e502, 0x7105e602, 0x7105e702, 0x7105e802, 0x7105e902, 0x7105ea02, 0x7105eb02, + 0x7105ec02, 0x7105ed02, 0x7105ee02, 0x7105ef02, 0x7105f002, 0x7105f102, 0x7105f202, 0x7105f302, + 0x7105f402, 0x7105f502, 0x7105f602, 0x7105f702, 0x7105f802, 0x7105f902, 0x7105fa02, 0x7105fb02, + 0x7105fc02, 0x7105fd02, 0x7105fe02, 0x7105ff02, 0x72050202, 0x72050302, 0x72050402, 0x72050502, + 0x72050602, 0x72050702, 0x72050802, 0x72050902, 0x72050a02, 0x72050b02, 0x72050c02, 0x72050d02, + 0x72050e02, 0x72050f02, 0x72051002, 0x72051102, 0x72051202, 0x72051302, 0x72051402, 0x72051502, + 0x72051602, 0x72051702, 0x72051802, 0x72051902, 0x72051a02, 0x72051b02, 0x72051c02, 0x72051d02, + 0x72051e02, 0x72051f02, 0x72052002, 0x72052102, 0x72052202, 0x72052302, 0x72052402, 0x72052502, + 0x72052602, 0x72052702, 0x72052802, 0x72052902, 0x72052a02, 0x72052b02, 0x72052c02, 0x72052d02, + 0x72052e02, 0x72052f02, 0x72053002, 0x72053102, 0x72053202, 0x72053302, 0x72053402, 0x72053502, + 0x72053602, 0x72053702, 0x72053802, 0x72053902, 0x72053a02, 0x72053b02, 0x72053c02, 0x72053d02, + 0x72053e02, 0x72053f02, 0x72054002, 0x72054102, 0x72054202, 0x72054302, 0x72054402, 0x72054502, + 0x72054602, 0x72054702, 0x72054802, 0x72054902, 0x72054a02, 0x72054b02, 0x72054c02, 0x72054d02, + 0x72054e02, 0x72054f02, 0x72055002, 0x72055102, 0x72055202, 0x72055302, 0x72055402, 0x72055502, + 0x72055602, 0x72055702, 0x72055802, 0x72055902, 0x72055a02, 0x72055b02, 0x72055c02, 0x72055d02, + 0x72055e02, 0x72055f02, 0x72056002, 0x72056102, 0x72056202, 0x72056302, 0x72056402, 0x72056502, + 0x72056602, 0x72056702, 0x72056802, 0x72056902, 0x72056a02, 0x72056b02, 0x72056c02, 0x72056d02, + 0x72056e02, 0x72056f02, 0x72057002, 0x72057102, 0x72057202, 0x72057302, 0x72057402, 0x72057502, + 0x72057602, 0x72057702, 0x72057802, 0x72057902, 0x72057a02, 0x72057b02, 0x72057c02, 0x72057d02, + 0x72057e02, 0x72057f02, 0x72058002, 0x72058102, 0x72058202, 0x72058302, 0x72058402, 0x72058502, + 0x72058602, 0x72058702, 0x72058802, 0x72058902, 0x72058a02, 0x72058b02, 0x72058c02, 0x72058d02, + 0x72058e02, 0x72058f02, 0x72059002, 0x72059102, 0x72059202, 0x72059302, 0x72059402, 0x72059502, + 0x72059602, 0x72059702, 0x72059802, 0x72059902, 0x72059a02, 0x72059b02, 0x72059c02, 0x72059d02, + 0x72059e02, 0x72059f02, 0x7205a002, 0x7205a102, 0x7205a202, 0x7205a302, 0x7205a402, 0x7205a502, + 0x7205a602, 0x7205a702, 0x7205a802, 0x7205a902, 0x7205aa02, 0x7205ab02, 0x7205ac02, 0x7205ad02, + 0x7205ae02, 0x7205af02, 0x7205b002, 0x7205b102, 0x7205b202, 0x7205b302, 0x7205b402, 0x7205b502, + 0x7205b602, 0x7205b702, 0x7205b802, 0x7205b902, 0x7205ba02, 0x7205bb02, 0x7205bc02, 0x7205bd02, + 0x7205be02, 0x7205bf02, 0x7205c002, 0x7205c102, 0x7205c202, 0x7205c302, 0x7205c402, 0x7205c502, + 0x7205c602, 0x7205c702, 0x7205c802, 0x7205c902, 0x7205ca02, 0x7205cb02, 0x7205cc02, 0x7205cd02, + 0x7205ce02, 0x7205cf02, 0x7205d002, 0x7205d102, 0x7205d202, 0x7205d302, 0x7205d402, 0x7205d502, + 0x7205d602, 0x7205d702, 0x7205d802, 0x7205d902, 0x7205da02, 0x7205db02, 0x7205dc02, 0x7205dd02, + 0x7205de02, 0x7205df02, 0x7205e002, 0x7205e102, 0x7205e202, 0x7205e302, 0x7205e402, 0x7205e502, + 0x7205e602, 0x7205e702, 0x7205e802, 0x7205e902, 0x7205ea02, 0x7205eb02, 0x7205ec02, 0x7205ed02, + 0x7205ee02, 0x7205ef02, 0x7205f002, 0x7205f102, 0x7205f202, 0x7205f302, 0x7205f402, 0x7205f502, + 0x7205f602, 0x7205f702, 0x7205f802, 0x7205f902, 0x7205fa02, 0x7205fb02, 0x7205fc02, 0x7205fd02, + 0x7205fe02, 0x7205ff02, 0x73050202, 0x73050302, 0x73050402, 0x73050502, 0x73050602, 0x73050702, + 0x73050802, 0x73050902, 0x73050a02, 0x73050b02, 0x73050c02, 0x73050d02, 0x73050e02, 0x73050f02, + 0x73051002, 0x73051102, 0x73051202, 0x73051302, 0x73051402, 0x73051502, 0x73051602, 0x73051702, + 0x73051802, 0x73051902, 0x73051a02, 0x73051b02, 0x73051c02, 0x73051d02, 0x73051e02, 0x73051f02, + 0x73052002, 0x73052102, 0x73052202, 0x73052302, 0x73052402, 0x73052502, 0x73052602, 0x73052702, + 0x73052802, 0x73052902, 0x73052a02, 0x73052b02, 0x73052c02, 0x73052d02, 0x73052e02, 0x73052f02, + 0x73053002, 0x73053102, 0x73053202, 0x73053302, 0x73053402, 0x73053502, 0x73053602, 0x73053702, + 0x73053802, 0x73053902, 0x73053a02, 0x73053b02, 0x73053c02, 0x73053d02, 0x73053e02, 0x73053f02, + 0x73054002, 0x73054102, 0x73054202, 0x73054302, 0x73054402, 0x73054502, 0x73054602, 0x73054702, + 0x73054802, 0x73054902, 0x73054a02, 0x73054b02, 0x73054c02, 0x73054d02, 0x73054e02, 0x73054f02, + 0x73055002, 0x73055102, 0x73055202, 0x73055302, 0x73055402, 0x73055502, 0x73055602, 0x73055702, + 0x73055802, 0x73055902, 0x73055a02, 0x73055b02, 0x73055c02, 0x73055d02, 0x73055e02, 0x73055f02, + 0x73056002, 0x73056102, 0x73056202, 0x73056302, 0x73056402, 0x73056502, 0x73056602, 0x73056702, + 0x73056802, 0x73056902, 0x73056a02, 0x73056b02, 0x73056c02, 0x73056d02, 0x73056e02, 0x73056f02, + 0x73057002, 0x73057102, 0x73057202, 0x73057302, 0x73057402, 0x73057502, 0x73057602, 0x73057702, + 0x73057802, 0x73057902, 0x73057a02, 0x73057b02, 0x73057c02, 0x73057d02, 0x73057e02, 0x73057f02, + 0x73058002, 0x73058102, 0x73058202, 0x73058302, 0x73058402, 0x73058502, 0x73058602, 0x73058702, + 0x73058802, 0x73058902, 0x73058a02, 0x73058b02, 0x73058c02, 0x73058d02, 0x73058e02, 0x73058f02, + 0x73059002, 0x73059102, 0x73059202, 0x73059302, 0x73059402, 0x73059502, 0x73059602, 0x73059702, + 0x73059802, 0x73059902, 0x73059a02, 0x73059b02, 0x73059c02, 0x73059d02, 0x73059e02, 0x73059f02, + 0x7305a002, 0x7305a102, 0x7305a202, 0x7305a302, 0x7305a402, 0x7305a502, 0x7305a602, 0x7305a702, + 0x7305a802, 0x7305a902, 0x7305aa02, 0x7305ab02, 0x7305ac02, 0x7305ad02, 0x7305ae02, 0x7305af02, + 0x7305b002, 0x7305b102, 0x7305b202, 0x7305b302, 0x7305b402, 0x7305b502, 0x7305b602, 0x7305b702, + 0x7305b802, 0x7305b902, 0x7305ba02, 0x7305bb02, 0x7305bc02, 0x7305bd02, 0x7305be02, 0x7305bf02, + 0x7305c002, 0x7305c102, 0x7305c202, 0x7305c302, 0x7305c402, 0x7305c502, 0x7305c602, 0x7305c702, + 0x7305c802, 0x7305c902, 0x7305ca02, 0x7305cb02, 0x7305cc02, 0x7305cd02, 0x7305ce02, 0x7305cf02, + 0x7305d002, 0x7305d102, 0x7305d202, 0x7305d302, 0x7305d402, 0x7305d502, 0x7305d602, 0x7305d702, + 0x7305d802, 0x7305d902, 0x7305da02, 0x7305db02, 0x7305dc02, 0x7305dd02, 0x7305de02, 0x7305df02, + 0x7305e002, 0x7305e102, 0x7305e202, 0x7305e302, 0x7305e402, 0x7305e502, 0x7305e602, 0x7305e702, + 0x7305e802, 0x7305e902, 0x7305ea02, 0x7305eb02, 0x7305ec02, 0x7305ed02, 0x7305ee02, 0x7305ef02, + 0x7305f002, 0x7305f102, 0x7305f202, 0x7305f302, 0x7305f402, 0x7305f502, 0x7305f602, 0x7305f702, + 0x7305f802, 0x7305f902, 0x7305fa02, 0x7305fb02, 0x7305fc02, 0x7305fd02, 0x7305fe02, 0x7305ff02, + 0x74050202, 0x74050302, 0x74050402, 0x74050502, 0x74050602, 0x74050702, 0x74050802, 0x74050902, + 0x74050a02, 0x74050b02, 0x74050c02, 0x74050d02, 0x74050e02, 0x74050f02, 0x74051002, 0x74051102, + 0x74051202, 0x74051302, 0x74051402, 0x74051502, 0x74051602, 0x74051702, 0x74051802, 0x74051902, + 0x74051a02, 0x74051b02, 0x74051c02, 0x74051d02, 0x74051e02, 0x74051f02, 0x74052002, 0x74052102, + 0x74052202, 0x74052302, 0x74052402, 0x74052502, 0x74052602, 0x74052702, 0x74052802, 0x74052902, + 0x74052a02, 0x74052b02, 0x74052c02, 0x74052d02, 0x74052e02, 0x74052f02, 0x74053002, 0x74053102, + 0x74053202, 0x74053302, 0x74053402, 0x74053502, 0x74053602, 0x74053702, 0x74053802, 0x74053902, + 0x74053a02, 0x74053b02, 0x74053c02, 0x74053d02, 0x74053e02, 0x74053f02, 0x74054002, 0x74054102, + 0x74054202, 0x74054302, 0x74054402, 0x74054502, 0x74054602, 0x74054702, 0x74054802, 0x74054902, + 0x74054a02, 0x74054b02, 0x74054c02, 0x74054d02, 0x74054e02, 0x74054f02, 0x74055002, 0x74055102, + 0x74055202, 0x74055302, 0x74055402, 0x74055502, 0x74055602, 0x74055702, 0x74055802, 0x74055902, + 0x74055a02, 0x74055b02, 0x74055c02, 0x74055d02, 0x74055e02, 0x74055f02, 0x74056002, 0x74056102, + 0x74056202, 0x74056302, 0x74056402, 0x74056502, 0x74056602, 0x74056702, 0x74056802, 0x74056902, + 0x74056a02, 0x74056b02, 0x74056c02, 0x74056d02, 0x74056e02, 0x74056f02, 0x74057002, 0x74057102, + 0x74057202, 0x74057302, 0x74057402, 0x74057502, 0x74057602, 0x74057702, 0x74057802, 0x74057902, + 0x74057a02, 0x74057b02, 0x74057c02, 0x74057d02, 0x74057e02, 0x74057f02, 0x74058002, 0x74058102, + 0x74058202, 0x74058302, 0x74058402, 0x74058502, 0x74058602, 0x74058702, 0x74058802, 0x74058902, + 0x74058a02, 0x74058b02, 0x74058c02, 0x74058d02, 0x74058e02, 0x74058f02, 0x74059002, 0x74059102, + 0x74059202, 0x74059302, 0x74059402, 0x74059502, 0x74059602, 0x74059702, 0x74059802, 0x74059902, + 0x74059a02, 0x74059b02, 0x74059c02, 0x74059d02, 0x74059e02, 0x74059f02, 0x7405a002, 0x7405a102, + 0x7405a202, 0x7405a302, 0x7405a402, 0x7405a502, 0x7405a602, 0x7405a702, 0x7405a802, 0x7405a902, + 0x7405aa02, 0x7405ab02, 0x7405ac02, 0x7405ad02, 0x7405ae02, 0x7405af02, 0x7405b002, 0x7405b102, + 0x7405b202, 0x7405b302, 0x7405b402, 0x7405b502, 0x7405b602, 0x7405b702, 0x7405b802, 0x7405b902, + 0x7405ba02, 0x7405bb02, 0x7405bc02, 0x7405bd02, 0x7405be02, 0x7405bf02, 0x7405c002, 0x7405c102, + 0x7405c202, 0x7405c302, 0x7405c402, 0x7405c502, 0x7405c602, 0x7405c702, 0x7405c802, 0x7405c902, + 0x7405ca02, 0x7405cb02, 0x7405cc02, 0x7405cd02, 0x7405ce02, 0x7405cf02, 0x7405d002, 0x7405d102, + 0x7405d202, 0x7405d302, 0x7405d402, 0x7405d502, 0x7405d602, 0x7405d702, 0x7405d802, 0x7405d902, + 0x7405da02, 0x7405db02, 0x7405dc02, 0x7405dd02, 0x7405de02, 0x7405df02, 0x7405e002, 0x7405e102, + 0x7405e202, 0x7405e302, 0x7405e402, 0x7405e502, 0x7405e602, 0x7405e702, 0x7405e802, 0x7405e902, + 0x7405ea02, 0x7405eb02, 0x7405ec02, 0x7405ed02, 0x7405ee02, 0x7405ef02, 0x7405f002, 0x7405f102, + 0x7405f202, 0x7405f302, 0x7405f402, 0x7405f502, 0x7405f602, 0x7405f702, 0x7405f802, 0x7405f902, + 0x7405fa02, 0x7405fb02, 0x7405fc02, 0x7405fd02, 0x7405fe02, 0x7405ff02, 0x75050202, 0x75050302, + 0x75050402, 0x75050502, 0x75050602, 0x75050702, 0x75050802, 0x75050902, 0x75050a02, 0x75050b02, + 0x75050c02, 0x75050d02, 0x75050e02, 0x75050f02, 0x75051002, 0x75051102, 0x75051202, 0x75051302, + 0x75051402, 0x75051502, 0x75051602, 0x75051702, 0x75051802, 0x75051902, 0x75051a02, 0x75051b02, + 0x75051c02, 0x75051d02, 0x75051e02, 0x75051f02, 0x75052002, 0x75052102, 0x75052202, 0x75052302, + 0x75052402, 0x75052502, 0x75052602, 0x75052702, 0x75052802, 0x75052902, 0x75052a02, 0x75052b02, + 0x75052c02, 0x75052d02, 0x75052e02, 0x75052f02, 0x75053002, 0x75053102, 0x75053202, 0x75053302, + 0x75053402, 0x75053502, 0x75053602, 0x75053702, 0x75053802, 0x75053902, 0x75053a02, 0x75053b02, + 0x75053c02, 0x75053d02, 0x75053e02, 0x75053f02, 0x75054002, 0x75054102, 0x75054202, 0x75054302, + 0x75054402, 0x75054502, 0x75054602, 0x75054702, 0x75054802, 0x75054902, 0x75054a02, 0x75054b02, + 0x75054c02, 0x75054d02, 0x75054e02, 0x75054f02, 0x75055002, 0x75055102, 0x75055202, 0x75055302, + 0x75055402, 0x75055502, 0x75055602, 0x75055702, 0x75055802, 0x75055902, 0x75055a02, 0x75055b02, + 0x75055c02, 0x75055d02, 0x75055e02, 0x75055f02, 0x75056002, 0x75056102, 0x75056202, 0x75056302, + 0x75056402, 0x75056502, 0x75056602, 0x75056702, 0x75056802, 0x75056902, 0x75056a02, 0x75056b02, + 0x75056c02, 0x75056d02, 0x75056e02, 0x75056f02, 0x75057002, 0x75057102, 0x75057202, 0x75057302, + 0x75057402, 0x75057502, 0x75057602, 0x75057702, 0x75057802, 0x75057902, 0x75057a02, 0x75057b02, + 0x75057c02, 0x75057d02, 0x75057e02, 0x75057f02, 0x75058002, 0x75058102, 0x75058202, 0x75058302, + 0x75058402, 0x75058502, 0x75058602, 0x75058702, 0x75058802, 0x75058902, 0x75058a02, 0x75058b02, + 0x75058c02, 0x75058d02, 0x75058e02, 0x75058f02, 0x75059002, 0x75059102, 0x75059202, 0x75059302, + 0x75059402, 0x75059502, 0x75059602, 0x75059702, 0x75059802, 0x75059902, 0x75059a02, 0x75059b02, + 0x75059c02, 0x75059d02, 0x75059e02, 0x75059f02, 0x7505a002, 0x7505a102, 0x7505a202, 0x7505a302, + 0x7505a402, 0x7505a502, 0x7505a602, 0x7505a702, 0x7505a802, 0x7505a902, 0x7505aa02, 0x7505ab02, + 0x7505ac02, 0x7505ad02, 0x7505ae02, 0x7505af02, 0x7505b002, 0x7505b102, 0x7505b202, 0x7505b302, + 0x7505b402, 0x7505b502, 0x7505b602, 0x7505b702, 0x7505b802, 0x7505b902, 0x7505ba02, 0x7505bb02, + 0x7505bc02, 0x7505bd02, 0x7505be02, 0x7505bf02, 0x7505c002, 0x7505c102, 0x7505c202, 0x7505c302, + 0x7505c402, 0x7505c502, 0x7505c602, 0x7505c702, 0x7505c802, 0x7505c902, 0x7505ca02, 0x7505cb02, + 0x7505cc02, 0x7505cd02, 0x7505ce02, 0x7505cf02, 0x7505d002, 0x7505d102, 0x7505d202, 0x7505d302, + 0x7505d402, 0x7505d502, 0x7505d602, 0x7505d702, 0x7505d802, 0x7505d902, 0x7505da02, 0x7505db02, + 0x7505dc02, 0x7505dd02, 0x7505de02, 0x7505df02, 0x7505e002, 0x7505e102, 0x7505e202, 0x7505e302, + 0x7505e402, 0x7505e502, 0x7505e602, 0x7505e702, 0x7505e802, 0x7505e902, 0x7505ea02, 0x7505eb02, + 0x7505ec02, 0x7505ed02, 0x7505ee02, 0x7505ef02, 0x7505f002, 0x7505f102, 0x7505f202, 0x7505f302, + 0x7505f402, 0x7505f502, 0x7505f602, 0x7505f702, 0x7505f802, 0x7505f902, 0x7505fa02, 0x7505fb02, + 0x7505fc02, 0x7505fd02, 0x7505fe02, 0x7505ff02, 0x76050202, 0x76050302, 0x76050402, 0x76050502, + 0x76050602, 0x76050702, 0x76050802, 0x76050902, 0x76050a02, 0x76050b02, 0x76050c02, 0x76050d02, + 0x76050e02, 0x76050f02, 0x76051002, 0x76051102, 0x76051202, 0x76051302, 0x76051402, 0x76051502, + 0x76051602, 0x76051702, 0x76051802, 0x76051902, 0x76051a02, 0x76051b02, 0x76051c02, 0x76051d02, + 0x76051e02, 0x76051f02, 0x76052002, 0x76052102, 0x76052202, 0x76052302, 0x76052402, 0x76052502, + 0x76052602, 0x76052702, 0x76052802, 0x76052902, 0x76052a02, 0x76052b02, 0x76052c02, 0x76052d02, + 0x76052e02, 0x76052f02, 0x76053002, 0x76053102, 0x76053202, 0x76053302, 0x76053402, 0x76053502, + 0x76053602, 0x76053702, 0x76053802, 0x76053902, 0x76053a02, 0x76053b02, 0x76053c02, 0x76053d02, + 0x76053e02, 0x76053f02, 0x76054002, 0x76054102, 0x76054202, 0x76054302, 0x76054402, 0x76054502, + 0x76054602, 0x76054702, 0x76054802, 0x76054902, 0x76054a02, 0x76054b02, 0x76054c02, 0x76054d02, + 0x76054e02, 0x76054f02, 0x76055002, 0x76055102, 0x76055202, 0x76055302, 0x76055402, 0x76055502, + 0x76055602, 0x76055702, 0x76055802, 0x76055902, 0x76055a02, 0x76055b02, 0x76055c02, 0x76055d02, + 0x76055e02, 0x76055f02, 0x76056002, 0x76056102, 0x76056202, 0x76056302, 0x76056402, 0x76056502, + 0x76056602, 0x76056702, 0x76056802, 0x76056902, 0x76056a02, 0x76056b02, 0x76056c02, 0x76056d02, + 0x76056e02, 0x76056f02, 0x76057002, 0x76057102, 0x76057202, 0x76057302, 0x76057402, 0x76057502, + 0x76057602, 0x76057702, 0x76057802, 0x76057902, 0x76057a02, 0x76057b02, 0x76057c02, 0x76057d02, + 0x76057e02, 0x76057f02, 0x76058002, 0x76058102, 0x76058202, 0x76058302, 0x76058402, 0x76058502, + 0x76058602, 0x76058702, 0x76058802, 0x76058902, 0x76058a02, 0x76058b02, 0x76058c02, 0x76058d02, + 0x76058e02, 0x76058f02, 0x76059002, 0x76059102, 0x76059202, 0x76059302, 0x76059402, 0x76059502, + 0x76059602, 0x76059702, 0x76059802, 0x76059902, 0x76059a02, 0x76059b02, 0x76059c02, 0x76059d02, + 0x76059e02, 0x76059f02, 0x7605a002, 0x7605a102, 0x7605a202, 0x7605a302, 0x7605a402, 0x7605a502, + 0x7605a602, 0x7605a702, 0x7605a802, 0x7605a902, 0x7605aa02, 0x7605ab02, 0x7605ac02, 0x7605ad02, + 0x7605ae02, 0x7605af02, 0x7605b002, 0x7605b102, 0x7605b202, 0x7605b302, 0x7605b402, 0x7605b502, + 0x7605b602, 0x7605b702, 0x7605b802, 0x7605b902, 0x7605ba02, 0x7605bb02, 0x7605bc02, 0x7605bd02, + 0x7605be02, 0x7605bf02, 0x7605c002, 0x7605c102, 0x7605c202, 0x7605c302, 0x7605c402, 0x7605c502, + 0x7605c602, 0x7605c702, 0x7605c802, 0x7605c902, 0x7605ca02, 0x7605cb02, 0x7605cc02, 0x7605cd02, + 0x7605ce02, 0x7605cf02, 0x7605d002, 0x7605d102, 0x7605d202, 0x7605d302, 0x7605d402, 0x7605d502, + 0x7605d602, 0x7605d702, 0x7605d802, 0x7605d902, 0x7605da02, 0x7605db02, 0x7605dc02, 0x7605dd02, + 0x7605de02, 0x7605df02, 0x7605e002, 0x7605e102, 0x7605e202, 0x7605e302, 0x7605e402, 0x7605e502, + 0x7605e602, 0x7605e702, 0x7605e802, 0x7605e902, 0x7605ea02, 0x7605eb02, 0x7605ec02, 0x7605ed02, + 0x7605ee02, 0x7605ef02, 0x7605f002, 0x7605f102, 0x7605f202, 0x7605f302, 0x7605f402, 0x7605f502, + 0x7605f602, 0x7605f702, 0x7605f802, 0x7605f902, 0x7605fa02, 0x7605fb02, 0x7605fc02, 0x7605fd02, + 0x7605fe02, 0x7605ff02, 0x77050202, 0x77050302, 0x77050402, 0x77050502, 0x77050602, 0x77050702, + 0x77050802, 0x77050902, 0x77050a02, 0x77050b02, 0x77050c02, 0x77050d02, 0x77050e02, 0x77050f02, + 0x77051002, 0x77051102, 0x77051202, 0x77051302, 0x77051402, 0x77051502, 0x77051602, 0x77051702, + 0x77051802, 0x77051902, 0x77051a02, 0x77051b02, 0x77051c02, 0x77051d02, 0x77051e02, 0x77051f02, + 0x77052002, 0x77052102, 0x77052202, 0x77052302, 0x77052402, 0x77052502, 0x77052602, 0x77052702, + 0x77052802, 0x77052902, 0x77052a02, 0x77052b02, 0x77052c02, 0x77052d02, 0x77052e02, 0x77052f02, + 0x77053002, 0x77053102, 0x77053202, 0x77053302, 0x77053402, 0x77053502, 0x77053602, 0x77053702, + 0x77053802, 0x77053902, 0x77053a02, 0x77053b02, 0x77053c02, 0x77053d02, 0x77053e02, 0x77053f02, + 0x77054002, 0x77054102, 0x77054202, 0x77054302, 0x77054402, 0x77054502, 0x77054602, 0x77054702, + 0x77054802, 0x77054902, 0x77054a02, 0x77054b02, 0x77054c02, 0x77054d02, 0x77054e02, 0x77054f02, + 0x77055002, 0x77055102, 0x77055202, 0x77055302, 0x77055402, 0x77055502, 0x77055602, 0x77055702, + 0x77055802, 0x77055902, 0x77055a02, 0x77055b02, 0x77055c02, 0x77055d02, 0x77055e02, 0x77055f02, + 0x77056002, 0x77056102, 0x77056202, 0x77056302, 0x77056402, 0x77056502, 0x77056602, 0x77056702, + 0x77056802, 0x77056902, 0x77056a02, 0x77056b02, 0x77056c02, 0x77056d02, 0x77056e02, 0x77056f02, + 0x77057002, 0x77057102, 0x77057202, 0x77057302, 0x77057402, 0x77057502, 0x77057602, 0x77057702, + 0x77057802, 0x77057902, 0x77057a02, 0x77057b02, 0x77057c02, 0x77057d02, 0x77057e02, 0x77057f02, + 0x77058002, 0x77058102, 0x77058202, 0x77058302, 0x77058402, 0x77058502, 0x77058602, 0x77058702, + 0x77058802, 0x77058902, 0x77058a02, 0x77058b02, 0x77058c02, 0x77058d02, 0x77058e02, 0x77058f02, + 0x77059002, 0x77059102, 0x77059202, 0x77059302, 0x77059402, 0x77059502, 0x77059602, 0x77059702, + 0x77059802, 0x77059902, 0x77059a02, 0x77059b02, 0x77059c02, 0x77059d02, 0x77059e02, 0x77059f02, + 0x7705a002, 0x7705a102, 0x7705a202, 0x7705a302, 0x7705a402, 0x7705a502, 0x7705a602, 0x7705a702, + 0x7705a802, 0x7705a902, 0x7705aa02, 0x7705ab02, 0x7705ac02, 0x7705ad02, 0x7705ae02, 0x7705af02, + 0x7705b002, 0x7705b102, 0x7705b202, 0x7705b302, 0x7705b402, 0x7705b502, 0x7705b602, 0x7705b702, + 0x7705b802, 0x7705b902, 0x7705ba02, 0x7705bb02, 0x7705bc02, 0x7705bd02, 0x7705be02, 0x7705bf02, + 0x7705c002, 0x7705c102, 0x7705c202, 0x7705c302, 0x7705c402, 0x7705c502, 0x7705c602, 0x7705c702, + 0x7705c802, 0x7705c902, 0x7705ca02, 0x7705cb02, 0x7705cc02, 0x7705cd02, 0x7705ce02, 0x7705cf02, + 0x7705d002, 0x7705d102, 0x7705d202, 0x7705d302, 0x7705d402, 0x7705d502, 0x7705d602, 0x7705d702, + 0x7705d802, 0x7705d902, 0x7705da02, 0x7705db02, 0x7705dc02, 0x7705dd02, 0x7705de02, 0x7705df02, + 0x7705e002, 0x7705e102, 0x7705e202, 0x7705e302, 0x7705e402, 0x7705e502, 0x7705e602, 0x7705e702, + 0x7705e802, 0x7705e902, 0x7705ea02, 0x7705eb02, 0x7705ec02, 0x7705ed02, 0x7705ee02, 0x7705ef02, + 0x7705f002, 0x7705f102, 0x7705f202, 0x7705f302, 0x7705f402, 0x7705f502, 0x7705f602, 0x7705f702, + 0x7705f802, 0x7705f902, 0x7705fa02, 0x7705fb02, 0x7705fc02, 0x7705fd02, 0x7705fe02, 0x7705ff02, + 0x78050202, 0x78050302, 0x78050402, 0x78050502, 0x78050602, 0x78050702, 0x78050802, 0x78050902, + 0x78050a02, 0x78050b02, 0x78050c02, 0x78050d02, 0x78050e02, 0x78050f02, 0x78051002, 0x78051102, + 0x78051202, 0x78051302, 0x78051402, 0x78051502, 0x78051602, 0x78051702, 0x78051802, 0x78051902, + 0x78051a02, 0x78051b02, 0x78051c02, 0x78051d02, 0x78051e02, 0x78051f02, 0x78052002, 0x78052102, + 0x78052202, 0x78052302, 0x78052402, 0x78052502, 0x78052602, 0x78052702, 0x78052802, 0x78052902, + 0x78052a02, 0x78052b02, 0x78052c02, 0x78052d02, 0x78052e02, 0x78052f02, 0x78053002, 0x78053102, + 0x78053202, 0x78053302, 0x78053402, 0x78053502, 0x78053602, 0x78053702, 0x78053802, 0x78053902, + 0x78053a02, 0x78053b02, 0x78053c02, 0x78053d02, 0x78053e02, 0x78053f02, 0x78054002, 0x78054102, + 0x78054202, 0x78054302, 0x78054402, 0x78054502, 0x78054602, 0x78054702, 0x78054802, 0x78054902, + 0x78054a02, 0x78054b02, 0x78054c02, 0x78054d02, 0x78054e02, 0x78054f02, 0x78055002, 0x78055102, + 0x78055202, 0x78055302, 0x78055402, 0x78055502, 0x78055602, 0x78055702, 0x78055802, 0x78055902, + 0x78055a02, 0x78055b02, 0x78055c02, 0x78055d02, 0x78055e02, 0x78055f02, 0x78056002, 0x78056102, + 0x78056202, 0x78056302, 0x78056402, 0x78056502, 0x78056602, 0x78056702, 0x78056802, 0x78056902, + 0x78056a02, 0x78056b02, 0x78056c02, 0x78056d02, 0x78056e02, 0x78056f02, 0x78057002, 0x78057102, + 0x78057202, 0x78057302, 0x78057402, 0x78057502, 0x78057602, 0x78057702, 0x78057802, 0x78057902, + 0x78057a02, 0x78057b02, 0x78057c02, 0x78057d02, 0x78057e02, 0x78057f02, 0x78058002, 0x78058102, + 0x78058202, 0x78058302, 0x78058402, 0x78058502, 0x78058602, 0x78058702, 0x78058802, 0x78058902, + 0x78058a02, 0x78058b02, 0x78058c02, 0x78058d02, 0x78058e02, 0x78058f02, 0x78059002, 0x78059102, + 0x78059202, 0x78059302, 0x78059402, 0x78059502, 0x78059602, 0x78059702, 0x78059802, 0x78059902, + 0x78059a02, 0x78059b02, 0x78059c02, 0x78059d02, 0x78059e02, 0x78059f02, 0x7805a002, 0x7805a102, + 0x7805a202, 0x7805a302, 0x7805a402, 0x7805a502, 0x7805a602, 0x7805a702, 0x7805a802, 0x7805a902, + 0x7805aa02, 0x7805ab02, 0x7805ac02, 0x7805ad02, 0x7805ae02, 0x7805af02, 0x7805b002, 0x7805b102, + 0x7805b202, 0x7805b302, 0x7805b402, 0x7805b502, 0x7805b602, 0x7805b702, 0x7805b802, 0x7805b902, + 0x7805ba02, 0x7805bb02, 0x7805bc02, 0x7805bd02, 0x7805be02, 0x7805bf02, 0x7805c002, 0x7805c102, + 0x7805c202, 0x7805c302, 0x7805c402, 0x7805c502, 0x7805c602, 0x7805c702, 0x7805c802, 0x7805c902, + 0x7805ca02, 0x7805cb02, 0x7805cc02, 0x7805cd02, 0x7805ce02, 0x7805cf02, 0x7805d002, 0x7805d102, + 0x7805d202, 0x7805d302, 0x7805d402, 0x7805d502, 0x7805d602, 0x7805d702, 0x7805d802, 0x7805d902, + 0x7805da02, 0x7805db02, 0x7805dc02, 0x7805dd02, 0x7805de02, 0x7805df02, 0x7805e002, 0x7805e102, + 0x7805e202, 0x7805e302, 0x7805e402, 0x7805e502, 0x7805e602, 0x7805e702, 0x7805e802, 0x7805e902, + 0x7805ea02, 0x7805eb02, 0x7805ec02, 0x7805ed02, 0x7805ee02, 0x7805ef02, 0x7805f002, 0x7805f102, + 0x7805f202, 0x7805f302, 0x7805f402, 0x7805f502, 0x7805f602, 0x7805f702, 0x7805f802, 0x7805f902, + 0x7805fa02, 0x7805fb02, 0x7805fc02, 0x7805fd02, 0x7805fe02, 0x7805ff02, 0x79050202, 0x79050302, + 0x79050402, 0x79050502, 0x79050602, 0x79050702, 0x79050802, 0x79050902, 0x79050a02, 0x79050b02, + 0x79050c02, 0x79050d02, 0x79050e02, 0x79050f02, 0x79051002, 0x79051102, 0x79051202, 0x79051302, + 0x79051402, 0x79051502, 0x79051602, 0x79051702, 0x79051802, 0x79051902, 0x79051a02, 0x79051b02, + 0x79051c02, 0x79051d02, 0x79051e02, 0x79051f02, 0x79052002, 0x79052102, 0x79052202, 0x79052302, + 0x79052402, 0x79052502, 0x79052602, 0x79052702, 0x79052802, 0x79052902, 0x79052a02, 0x79052b02, + 0x79052c02, 0x79052d02, 0x79052e02, 0x79052f02, 0x79053002, 0x79053102, 0x79053202, 0x79053302, + 0x79053402, 0x79053502, 0x79053602, 0x79053702, 0x79053802, 0x79053902, 0x79053a02, 0x79053b02, + 0x79053c02, 0x79053d02, 0x79053e02, 0x79053f02, 0x79054002, 0x79054102, 0x79054202, 0x79054302, + 0x79054402, 0x79054502, 0x79054602, 0x79054702, 0x79054802, 0x79054902, 0x79054a02, 0x79054b02, + 0x79054c02, 0x79054d02, 0x79054e02, 0x79054f02, 0x79055002, 0x79055102, 0x79055202, 0x79055302, + 0x79055402, 0x79055502, 0x79055602, 0x79055702, 0x79055802, 0x79055902, 0x79055a02, 0x79055b02, + 0x79055c02, 0x79055d02, 0x79055e02, 0x79055f02, 0x79056002, 0x79056102, 0x79056202, 0x79056302, + 0x79056402, 0x79056502, 0x79056602, 0x79056702, 0x79056802, 0x79056902, 0x79056a02, 0x79056b02, + 0x79056c02, 0x79056d02, 0x79056e02, 0x79056f02, 0x79057002, 0x79057102, 0x79057202, 0x79057302, + 0x79057402, 0x79057502, 0x79057602, 0x79057702, 0x79057802, 0x79057902, 0x79057a02, 0x79057b02, + 0x79057c02, 0x79057d02, 0x79057e02, 0x79057f02, 0x79058002, 0x79058102, 0x79058202, 0x79058302, + 0x79058402, 0x79058502, 0x79058602, 0x79058702, 0x79058802, 0x79058902, 0x79058a02, 0x79058b02, + 0x79058c02, 0x79058d02, 0x79058e02, 0x79058f02, 0x79059002, 0x79059102, 0x79059202, 0x79059302, + 0x79059402, 0x79059502, 0x79059602, 0x79059702, 0x79059802, 0x79059902, 0x79059a02, 0x79059b02, + 0x79059c02, 0x79059d02, 0x79059e02, 0x79059f02, 0x7905a002, 0x7905a102, 0x7905a202, 0x7905a302, + 0x7905a402, 0x7905a502, 0x7905a602, 0x7905a702, 0x7905a802, 0x7905a902, 0x7905aa02, 0x7905ab02, + 0x7905ac02, 0x7905ad02, 0x7905ae02, 0x7905af02, 0x7905b002, 0x7905b102, 0x7905b202, 0x7905b302, + 0x7905b402, 0x7905b502, 0x7905b602, 0x7905b702, 0x7905b802, 0x7905b902, 0x7905ba02, 0x7905bb02, + 0x7905bc02, 0x7905bd02, 0x7905be02, 0x7905bf02, 0x7905c002, 0x7905c102, 0x7905c202, 0x7905c302, + 0x7905c402, 0x7905c502, 0x7905c602, 0x7905c702, 0x7905c802, 0x7905c902, 0x7905ca02, 0x7905cb02, + 0x7905cc02, 0x7905cd02, 0x7905ce02, 0x7905cf02, 0x7905d002, 0x7905d102, 0x7905d202, 0x7905d302, + 0x7905d402, 0x7905d502, 0x7905d602, 0x7905d702, 0x7905d802, 0x7905d902, 0x7905da02, 0x7905db02, + 0x7905dc02, 0x7905dd02, 0x7905de02, 0x7905df02, 0x7905e002, 0x7905e102, 0x7905e202, 0x7905e302, + 0x7905e402, 0x7905e502, 0x7905e602, 0x7905e702, 0x7905e802, 0x7905e902, 0x7905ea02, 0x7905eb02, + 0x7905ec02, 0x7905ed02, 0x7905ee02, 0x7905ef02, 0x7905f002, 0x7905f102, 0x7905f202, 0x7905f302, + 0x7905f402, 0x7905f502, 0x7905f602, 0x7905f702, 0x7905f802, 0x7905f902, 0x7905fa02, 0x7905fb02, + 0x7905fc02, 0x7905fd02, 0x7905fe02, 0x7905ff02, 0x7a050202, 0x7a050302, 0x7a050402, 0x7a050502, + 0x7a050602, 0x7a050702, 0x7a050802, 0x7a050902, 0x7a050a02, 0x7a050b02, 0x7a050c02, 0x7a050d02, + 0x7a050e02, 0x7a050f02, 0x7a051002, 0x7a051102, 0x7a051202, 0x7a051302, 0x7a051402, 0x7a051502, + 0x7a051602, 0x7a051702, 0x7a051802, 0x7a051902, 0x7a051a02, 0x7a051b02, 0x7a051c02, 0x7a051d02, + 0x7a051e02, 0x7a051f02, 0x7a052002, 0x7a052102, 0x7a052202, 0x7a052302, 0x7a052402, 0x7a052502, + 0x7a052602, 0x7a052702, 0x7a052802, 0x7a052902, 0x7a052a02, 0x7a052b02, 0x7a052c02, 0x7a052d02, + 0x7a052e02, 0x7a052f02, 0x7a053002, 0x7a053102, 0x7a053202, 0x7a053302, 0x7a053402, 0x7a053502, + 0x7a053602, 0x7a053702, 0x7a053802, 0x7a053902, 0x7a053a02, 0x7a053b02, 0x7a053c02, 0x7a053d02, + 0x7a053e02, 0x7a053f02, 0x7a054002, 0x7a054102, 0x7a054202, 0x7a054302, 0x7a054402, 0x7a054502, + 0x7a054602, 0x7a054702, 0x7a054802, 0x7a054902, 0x7a054a02, 0x7a054b02, 0x7a054c02, 0x7a054d02, + 0x7a054e02, 0x7a054f02, 0x7a055002, 0x7a055102, 0x7a055202, 0x7a055302, 0x7a055402, 0x7a055502, + 0x7a055602, 0x7a055702, 0x7a055802, 0x7a055902, 0x7a055a02, 0x7a055b02, 0x7a055c02, 0x7a055d02, + 0x7a055e02, 0x7a055f02, 0x7a056002, 0x7a056102, 0x7a056202, 0x7a056302, 0x7a056402, 0x7a056502, + 0x7a056602, 0x7a056702, 0x7a056802, 0x7a056902, 0x7a056a02, 0x7a056b02, 0x7a056c02, 0x7a056d02, + 0x7a056e02, 0x7a056f02, 0x7a057002, 0x7a057102, 0x7a057202, 0x7a057302, 0x7a057402, 0x7a057502, + 0x7a057602, 0x7a057702, 0x7a057802, 0x7a057902, 0x7a057a02, 0x7a057b02, 0x7a057c02, 0x7a057d02, + 0x7a057e02, 0x7a057f02, 0x7a058002, 0x7a058102, 0x7a058202, 0x7a058302, 0x7a058402, 0x7a058502, + 0x7a058602, 0x7a058702, 0x7a058802, 0x7a058902, 0x7a058a02, 0x7a058b02, 0x7a058c02, 0x7a058d02, + 0x7a058e02, 0x7a058f02, 0x7a059002, 0x7a059102, 0x7a059202, 0x7a059302, 0x7a059402, 0x7a059502, + 0x7a059602, 0x7a059702, 0x7a059802, 0x7a059902, 0x7a059a02, 0x7a059b02, 0x7a059c02, 0x7a059d02, + 0x7a059e02, 0x7a059f02, 0x7a05a002, 0x7a05a102, 0x7a05a202, 0x7a05a302, 0x7a05a402, 0x7a05a502, + 0x7a05a602, 0x7a05a702, 0x7a05a802, 0x7a05a902, 0x7a05aa02, 0x7a05ab02, 0x7a05ac02, 0x7a05ad02, + 0x7a05ae02, 0x7a05af02, 0x7a05b002, 0x7a05b102, 0x7a05b202, 0x7a05b302, 0x7a05b402, 0x7a05b502, + 0x7a05b602, 0x7a05b702, 0x7a05b802, 0x7a05b902, 0x7a05ba02, 0x7a05bb02, 0x7a05bc02, 0x7a05bd02, + 0x7a05be02, 0x7a05bf02, 0x7a05c002, 0x7a05c102, 0x7a05c202, 0x7a05c302, 0x7a05c402, 0x7a05c502, + 0x7a05c602, 0x7a05c702, 0x7a05c802, 0x7a05c902, 0x7a05ca02, 0x7a05cb02, 0x7a05cc02, 0x7a05cd02, + 0x7a05ce02, 0x7a05cf02, 0x7a05d002, 0x7a05d102, 0x7a05d202, 0x7a05d302, 0x7a05d402, 0x7a05d502, + 0x7a05d602, 0x7a05d702, 0x7a05d802, 0x7a05d902, 0x7a05da02, 0x7a05db02, 0x7a05dc02, 0x7a05dd02, + 0x7a05de02, 0x7a05df02, 0x7a05e002, 0x7a05e102, 0x7a05e202, 0x7a05e302, 0x7a05e402, 0x7a05e502, + 0x7a05e602, 0x7a05e702, 0x7a05e802, 0x7a05e902, 0x7a05ea02, 0x7a05eb02, 0x7a05ec02, 0x7a05ed02, + 0x7a05ee02, 0x7a05ef02, 0x7a05f002, 0x7a05f102, 0x7a05f202, 0x7a05f302, 0x7a05f402, 0x7a05f502, + 0x7a05f602, 0x7a05f702, 0x7a05f802, 0x7a05f902, 0x7a05fa02, 0x7a05fb02, 0x7a05fc02, 0x7a05fd02, + 0x7a05fe02, 0x7a05ff02, 0x7b050202, 0x7b050302, 0x7b050402, 0x7b050502, 0x7b050602, 0x7b050702, + 0x7b050802, 0x7b050902, 0x7b050a02, 0x7b050b02, 0x7b050c02, 0x7b050d02, 0x7b050e02, 0x7b050f02, + 0x7b051002, 0x7b051102, 0x7b051202, 0x7b051302, 0x7b051402, 0x7b051502, 0x7b051602, 0x7b051702, + 0x7b051802, 0x7b051902, 0x7b051a02, 0x7b051b02, 0x7b051c02, 0x7b051d02, 0x7b051e02, 0x7b051f02, + 0x7b052002, 0x7b052102, 0x7b052202, 0x7b052302, 0x7b052402, 0x7b052502, 0x7b052602, 0x7b052702, + 0x7b052802, 0x7b052902, 0x7b052a02, 0x7b052b02, 0x7b052c02, 0x7b052d02, 0x7b052e02, 0x7b052f02, + 0x7b053002, 0x7b053102, 0x7b053202, 0x7b053302, 0x7b053402, 0x7b053502, 0x7b053602, 0x7b053702, + 0x7b053802, 0x7b053902, 0x7b053a02, 0x7b053b02, 0x7b053c02, 0x7b053d02, 0x7b053e02, 0x7b053f02, + 0x7b054002, 0x7b054102, 0x7b054202, 0x7b054302, 0x7b054402, 0x7b054502, 0x7b054602, 0x7b054702, + 0x7b054802, 0x7b054902, 0x7b054a02, 0x7b054b02, 0x7b054c02, 0x7b054d02, 0x7b054e02, 0x7b054f02, + 0x7b055002, 0x7b055102, 0x7b055202, 0x7b055302, 0x7b055402, 0x7b055502, 0x7b055602, 0x7b055702, + 0x7b055802, 0x7b055902, 0x7b055a02, 0x7b055b02, 0x7b055c02, 0x7b055d02, 0x7b055e02, 0x7b055f02, + 0x7b056002, 0x7b056102, 0x7b056202, 0x7b056302, 0x7b056402, 0x7b056502, 0x7b056602, 0x7b056702, + 0x7b056802, 0x7b056902, 0x7b056a02, 0x7b056b02, 0x7b056c02, 0x7b056d02, 0x7b056e02, 0x7b056f02, + 0x7b057002, 0x7b057102, 0x7b057202, 0x7b057302, 0x7b057402, 0x7b057502, 0x7b057602, 0x7b057702, + 0x7b057802, 0x7b057902, 0x7b057a02, 0x7b057b02, 0x7b057c02, 0x7b057d02, 0x7b057e02, 0x7b057f02, + 0x7b058002, 0x7b058102, 0x7b058202, 0x7b058302, 0x7b058402, 0x7b058502, 0x7b058602, 0x7b058702, + 0x7b058802, 0x7b058902, 0x7b058a02, 0x7b058b02, 0x7b058c02, 0x7b058d02, 0x7b058e02, 0x7b058f02, + 0x7b059002, 0x7b059102, 0x7b059202, 0x7b059302, 0x7b059402, 0x7b059502, 0x7b059602, 0x7b059702, + 0x7b059802, 0x7b059902, 0x7b059a02, 0x7b059b02, 0x7b059c02, 0x7b059d02, 0x7b059e02, 0x7b059f02, + 0x7b05a002, 0x7b05a102, 0x7b05a202, 0x7b05a302, 0x7b05a402, 0x7b05a502, 0x7b05a602, 0x7b05a702, + 0x7b05a802, 0x7b05a902, 0x7b05aa02, 0x7b05ab02, 0x7b05ac02, 0x7b05ad02, 0x7b05ae02, 0x7b05af02, + 0x7b05b002, 0x7b05b102, 0x7b05b202, 0x7b05b302, 0x7b05b402, 0x7b05b502, 0x7b05b602, 0x7b05b702, + 0x7b05b802, 0x7b05b902, 0x7b05ba02, 0x7b05bb02, 0x7b05bc02, 0x7b05bd02, 0x7b05be02, 0x7b05bf02, + 0x7b05c002, 0x7b05c102, 0x7b05c202, 0x7b05c302, 0x7b05c402, 0x7b05c502, 0x7b05c602, 0x7b05c702, + 0x7b05c802, 0x7b05c902, 0x7b05ca02, 0x7b05cb02, 0x7b05cc02, 0x7b05cd02, 0x7b05ce02, 0x7b05cf02, + 0x7b05d002, 0x7b05d102, 0x7b05d202, 0x7b05d302, 0x7b05d402, 0x7b05d502, 0x7b05d602, 0x7b05d702, + 0x7b05d802, 0x7b05d902, 0x7b05da02, 0x7b05db02, 0x7b05dc02, 0x7b05dd02, 0x7b05de02, 0x7b05df02, + 0x7b05e002, 0x7b05e102, 0x7b05e202, 0x7b05e302, 0x7b05e402, 0x7b05e502, 0x7b05e602, 0x7b05e702, + 0x7b05e802, 0x7b05e902, 0x7b05ea02, 0x7b05eb02, 0x7b05ec02, 0x7b05ed02, 0x7b05ee02, 0x7b05ef02, + 0x7b05f002, 0x7b05f102, 0x7b05f202, 0x7b05f302, 0x7b05f402, 0x7b05f502, 0x7b05f602, 0x7b05f702, + 0x7b05f802, 0x7b05f902, 0x7b05fa02, 0x7b05fb02, 0x7b05fc02, 0x7b05fd02, 0x7b05fe02, 0x7b05ff02, + 0x7c050202, 0x7c050302, 0x7c050402, 0x7c050502, 0x7c050602, 0x7c050702, 0x7c050802, 0x7c050902, + 0x7c050a02, 0x7c050b02, 0x7c050c02, 0x7c050d02, 0x7c050e02, 0x7c050f02, 0x7c051002, 0x7c051102, + 0x7c051202, 0x7c051302, 0x7c051402, 0x7c051502, 0x7c051602, 0x7c051702, 0x7c051802, 0x7c051902, + 0x7c051a02, 0x7c051b02, 0x7c051c02, 0x7c051d02, 0x7c051e02, 0x7c051f02, 0x7c052002, 0x7c052102, + 0x7c052202, 0x7c052302, 0x7c052402, 0x7c052502, 0x7c052602, 0x7c052702, 0x7c052802, 0x7c052902, + 0x7c052a02, 0x7c052b02, 0x7c052c02, 0x7c052d02, 0x7c052e02, 0x7c052f02, 0x7c053002, 0x7c053102, + 0x7c053202, 0x7c053302, 0x7c053402, 0x7c053502, 0x7c053602, 0x7c053702, 0x7c053802, 0x7c053902, + 0x7c053a02, 0x7c053b02, 0x7c053c02, 0x7c053d02, 0x7c053e02, 0x7c053f02, 0x7c054002, 0x7c054102, + 0x7c054202, 0x7c054302, 0x7c054402, 0x7c054502, 0x7c054602, 0x7c054702, 0x7c054802, 0x7c054902, + 0x7c054a02, 0x7c054b02, 0x7c054c02, 0x7c054d02, 0x7c054e02, 0x7c054f02, 0x7c055002, 0x7c055102, + 0x7c055202, 0x7c055302, 0x7c055402, 0x7c055502, 0x7c055602, 0x7c055702, 0x7c055802, 0x7c055902, + 0x7c055a02, 0x7c055b02, 0x7c055c02, 0x7c055d02, 0x7c055e02, 0x7c055f02, 0x7c056002, 0x7c056102, + 0x7c056202, 0x7c056302, 0x7c056402, 0x7c056502, 0x7c056602, 0x7c056702, 0x7c056802, 0x7c056902, + 0x7c056a02, 0x7c056b02, 0x7c056c02, 0x7c056d02, 0x7c056e02, 0x7c056f02, 0x7c057002, 0x7c057102, + 0x7c057202, 0x7c057302, 0x7c057402, 0x7c057502, 0x7c057602, 0x7c057702, 0x7c057802, 0x7c057902, + 0x7c057a02, 0x7c057b02, 0x7c057c02, 0x7c057d02, 0x7c057e02, 0x7c057f02, 0x7c058002, 0x7c058102, + 0x7c058202, 0x7c058302, 0x7c058402, 0x7c058502, 0x7c058602, 0x7c058702, 0x7c058802, 0x7c058902, + 0x7c058a02, 0x7c058b02, 0x7c058c02, 0x7c058d02, 0x7c058e02, 0x7c058f02, 0x7c059002, 0x7c059102, + 0x7c059202, 0x7c059302, 0x7c059402, 0x7c059502, 0x7c059602, 0x7c059702, 0x7c059802, 0x7c059902, + 0x7c059a02, 0x7c059b02, 0x7c059c02, 0x7c059d02, 0x7c059e02, 0x7c059f02, 0x7c05a002, 0x7c05a102, + 0x7c05a202, 0x7c05a302, 0x7c05a402, 0x7c05a502, 0x7c05a602, 0x7c05a702, 0x7c05a802, 0x7c05a902, + 0x7c05aa02, 0x7c05ab02, 0x7c05ac02, 0x7c05ad02, 0x7c05ae02, 0x7c05af02, 0x7c05b002, 0x7c05b102, + 0x7c05b202, 0x7c05b302, 0x7c05b402, 0x7c05b502, 0x7c05b602, 0x7c05b702, 0x7c05b802, 0x7c05b902, + 0x7c05ba02, 0x7c05bb02, 0x7c05bc02, 0x7c05bd02, 0x7c05be02, 0x7c05bf02, 0x7c05c002, 0x7c05c102, + 0x7c05c202, 0x7c05c302, 0x7c05c402, 0x7c05c502, 0x7c05c602, 0x7c05c702, 0x7c05c802, 0x7c05c902, + 0x7c05ca02, 0x7c05cb02, 0x7c05cc02, 0x7c05cd02, 0x7c05ce02, 0x7c05cf02, 0x7c05d002, 0x7c05d102, + 0x7c05d202, 0x7c05d302, 0x7c05d402, 0x7c05d502, 0x7c05d602, 0x7c05d702, 0x7c05d802, 0x7c05d902, + 0x7c05da02, 0x7c05db02, 0x7c05dc02, 0x7c05dd02, 0x7c05de02, 0x7c05df02, 0x7c05e002, 0x7c05e102, + 0x7c05e202, 0x7c05e302, 0x7c05e402, 0x7c05e502, 0x7c05e602, 0x7c05e702, 0x7c05e802, 0x7c05e902, + 0x7c05ea02, 0x7c05eb02, 0x7c05ec02, 0x7c05ed02, 0x7c05ee02, 0x7c05ef02, 0x7c05f002, 0x7c05f102, + 0x7c05f202, 0x7c05f302, 0x7c05f402, 0x7c05f502, 0x7c05f602, 0x7c05f702, 0x7c05f802, 0x7c05f902, + 0x7c05fa02, 0x7c05fb02, 0x7c05fc02, 0x7c05fd02, 0x7c05fe02, 0x7c05ff02, 0x7d050202, 0x7d050302, + 0x7d050402, 0x7d050502, 0x7d050602, 0x7d050702, 0x7d050802, 0x7d050902, 0x7d050a02, 0x7d050b02, + 0x7d050c02, 0x7d050d02, 0x7d050e02, 0x7d050f02, 0x7d051002, 0x7d051102, 0x7d051202, 0x7d051302, + 0x7d051402, 0x7d051502, 0x7d051602, 0x7d051702, 0x7d051802, 0x7d051902, 0x7d051a02, 0x7d051b02, + 0x7d051c02, 0x7d051d02, 0x7d051e02, 0x7d051f02, 0x7d052002, 0x7d052102, 0x7d052202, 0x7d052302, + 0x7d052402, 0x7d052502, 0x7d052602, 0x7d052702, 0x7d052802, 0x7d052902, 0x7d052a02, 0x7d052b02, + 0x7d052c02, 0x7d052d02, 0x7d052e02, 0x7d052f02, 0x7d053002, 0x7d053102, 0x7d053202, 0x7d053302, + 0x7d053402, 0x7d053502, 0x7d053602, 0x7d053702, 0x7d053802, 0x7d053902, 0x7d053a02, 0x7d053b02, + 0x7d053c02, 0x7d053d02, 0x7d053e02, 0x7d053f02, 0x7d054002, 0x7d054102, 0x7d054202, 0x7d054302, + 0x7d054402, 0x7d054502, 0x7d054602, 0x7d054702, 0x7d054802, 0x7d054902, 0x7d054a02, 0x7d054b02, + 0x7d054c02, 0x7d054d02, 0x7d054e02, 0x7d054f02, 0x7d055002, 0x7d055102, 0x7d055202, 0x7d055302, + 0x7d055402, 0x7d055502, 0x7d055602, 0x7d055702, 0x7d055802, 0x7d055902, 0x7d055a02, 0x7d055b02, + 0x7d055c02, 0x7d055d02, 0x7d055e02, 0x7d055f02, 0x7d056002, 0x7d056102, 0x7d056202, 0x7d056302, + 0x7d056402, 0x7d056502, 0x7d056602, 0x7d056702, 0x7d056802, 0x7d056902, 0x7d056a02, 0x7d056b02, + 0x7d056c02, 0x7d056d02, 0x7d056e02, 0x7d056f02, 0x7d057002, 0x7d057102, 0x7d057202, 0x7d057302, + 0x7d057402, 0x7d057502, 0x7d057602, 0x7d057702, 0x7d057802, 0x7d057902, 0x7d057a02, 0x7d057b02, + 0x7d057c02, 0x7d057d02, 0x7d057e02, 0x7d057f02, 0x7d058002, 0x7d058102, 0x7d058202, 0x7d058302, + 0x7d058402, 0x7d058502, 0x7d058602, 0x7d058702, 0x7d058802, 0x7d058902, 0x7d058a02, 0x7d058b02, + 0x7d058c02, 0x7d058d02, 0x7d058e02, 0x7d058f02, 0x7d059002, 0x7d059102, 0x7d059202, 0x7d059302, + 0x7d059402, 0x7d059502, 0x7d059602, 0x7d059702, 0x7d059802, 0x7d059902, 0x7d059a02, 0x7d059b02, + 0x7d059c02, 0x7d059d02, 0x7d059e02, 0x7d059f02, 0x7d05a002, 0x7d05a102, 0x7d05a202, 0x7d05a302, + 0x7d05a402, 0x7d05a502, 0x7d05a602, 0x7d05a702, 0x7d05a802, 0x7d05a902, 0x7d05aa02, 0x7d05ab02, + 0x7d05ac02, 0x7d05ad02, 0x7d05ae02, 0x7d05af02, 0x7d05b002, 0x7d05b102, 0x7d05b202, 0x7d05b302, + 0x7d05b402, 0x7d05b502, 0x7d05b602, 0x7d05b702, 0x7d05b802, 0x7d05b902, 0x7d05ba02, 0x7d05bb02, + 0x7d05bc02, 0x7d05bd02, 0x7d05be02, 0x7d05bf02, 0x7d05c002, 0x7d05c102, 0x7d05c202, 0x7d05c302, + 0x7d05c402, 0x7d05c502, 0x7d05c602, 0x7d05c702, 0x7d05c802, 0x7d05c902, 0x7d05ca02, 0x7d05cb02, + 0x7d05cc02, 0x7d05cd02, 0x7d05ce02, 0x7d05cf02, 0x7d05d002, 0x7d05d102, 0x7d05d202, 0x7d05d302, + 0x7d05d402, 0x7d05d502, 0x7d05d602, 0x7d05d702, 0x7d05d802, 0x7d05d902, 0x7d05da02, 0x7d05db02, + 0x7d05dc02, 0x7d05dd02, 0x7d05de02, 0x7d05df02, 0x7d05e002, 0x7d05e102, 0x7d05e202, 0x7d05e302, + 0x7d05e402, 0x7d05e502, 0x7d05e602, 0x7d05e702, 0x7d05e802, 0x7d05e902, 0x7d05ea02, 0x7d05eb02, + 0x7d05ec02, 0x7d05ed02, 0x7d05ee02, 0x7d05ef02, 0x7d05f002, 0x7d05f102, 0x7d05f202, 0x7d05f302, + 0x7d05f402, 0x7d05f502, 0x7d05f602, 0x7d05f702, 0x7d05f802, 0x7d05f902, 0x7d05fa02, 0x7d05fb02, + 0x7d05fc02, 0x7d05fd02, 0x7d05fe02, 0x7d05ff02, 0x7e050202, 0x7e050302, 0x7e050402, 0x7e050502, + 0x7e050602, 0x7e050702, 0x7e050802, 0x7e050902, 0x7e050a02, 0x7e050b02, 0x7e050c02, 0x7e050d02, + 0x7e050e02, 0x7e050f02, 0x7e051002, 0x7e051102, 0x7e051202, 0x7e051302, 0x7e051402, 0x7e051502, + 0x7e051602, 0x7e051702, 0x7e051802, 0x7e051902, 0x7e051a02, 0x7e051b02, 0x7e051c02, 0x7e051d02, + 0x7e051e02, 0x7e051f02, 0x7e052002, 0x7e052102, 0x7e052202, 0x7e052302, 0x7e052402, 0x7e052502, + 0x7e052602, 0x7e052702, 0x7e052802, 0x7e052902, 0x7e052a02, 0x7e052b02, 0x7e052c02, 0x7e052d02, + 0x7e052e02, 0x7e052f02, 0x7e053002, 0x7e053102, 0x7e053202, 0x7e053302, 0x7e053402, 0x7e053502, + 0x7e053602, 0x7e053702, 0x7e053802, 0x7e053902, 0x7e053a02, 0x7e053b02, 0x7e053c02, 0x7e053d02, + 0x7e053e02, 0x7e053f02, 0x7e054002, 0x7e054102, 0x7e054202, 0x7e054302, 0x7e054402, 0x7e054502, + 0x7e054602, 0x7e054702, 0x7e054802, 0x7e054902, 0x7e054a02, 0x7e054b02, 0x7e054c02, 0x7e054d02, + 0x7e054e02, 0x7e054f02, 0x7e055002, 0x7e055102, 0x7e055202, 0x7e055302, 0x7e055402, 0x7e055502, + 0x7e055602, 0x7e055702, 0x7e055802, 0x7e055902, 0x7e055a02, 0x7e055b02, 0x7e055c02, 0x7e055d02, + 0x7e055e02, 0x7e055f02, 0x7e056002, 0x7e056102, 0x7e056202, 0x7e056302, 0x7e056402, 0x7e056502, + 0x7e056602, 0x7e056702, 0x7e056802, 0x7e056902, 0x7e056a02, 0x7e056b02, 0x7e056c02, 0x7e056d02, + 0x7e056e02, 0x7e056f02, 0x7e057002, 0x7e057102, 0x7e057202, 0x7e057302, 0x7e057402, 0x7e057502, + 0x7e057602, 0x7e057702, 0x7e057802, 0x7e057902, 0x7e057a02, 0x7e057b02, 0x7e057c02, 0x7e057d02, + 0x7e057e02, 0x7e057f02, 0x7e058002, 0x7e058102, 0x7e058202, 0x7e058302, 0x7e058402, 0x7e058502, + 0x7e058602, 0x7e058702, 0x7e058802, 0x7e058902, 0x7e058a02, 0x7e058b02, 0x7e058c02, 0x7e058d02, + 0x7e058e02, 0x7e058f02, 0x7e059002, 0x7e059102, 0x7e059202, 0x7e059302, 0x7e059402, 0x7e059502, + 0x7e059602, 0x7e059702, 0x7e059802, 0x7e059902, 0x7e059a02, 0x7e059b02, 0x7e059c02, 0x7e059d02, + 0x7e059e02, 0x7e059f02, 0x7e05a002, 0x7e05a102, 0x7e05a202, 0x7e05a302, 0x7e05a402, 0x7e05a502, + 0x7e05a602, 0x7e05a702, 0x7e05a802, 0x7e05a902, 0x7e05aa02, 0x7e05ab02, 0x7e05ac02, 0x7e05ad02, + 0x7e05ae02, 0x7e05af02, 0x7e05b002, 0x7e05b102, 0x7e05b202, 0x7e05b302, 0x7e05b402, 0x7e05b502, + 0x7e05b602, 0x7e05b702, 0x7e05b802, 0x7e05b902, 0x7e05ba02, 0x7e05bb02, 0x7e05bc02, 0x7e05bd02, + 0x7e05be02, 0x7e05bf02, 0x7e05c002, 0x7e05c102, 0x7e05c202, 0x7e05c302, 0x7e05c402, 0x7e05c502, + 0x7e05c602, 0x7e05c702, 0x7e05c802, 0x7e05c902, 0x7e05ca02, 0x7e05cb02, 0x7e05cc02, 0x7e05cd02, + 0x7e05ce02, 0x7e05cf02, 0x7e05d002, 0x7e05d102, 0x7e05d202, 0x7e05d302, 0x7e05d402, 0x7e05d502, + 0x7e05d602, 0x7e05d702, 0x7e05d802, 0x7e05d902, 0x7e05da02, 0x7e05db02, 0x7e05dc02, 0x7e05dd02, + 0x7e05de02, 0x7e05df02, 0x7e05e002, 0x7e05e102, 0x7e05e202, 0x7e05e302, 0x7e05e402, 0x7e05e502, + 0x7e05e602, 0x7e05e702, 0x7e05e802, 0x7e05e902, 0x7e05ea02, 0x7e05eb02, 0x7e05ec02, 0x7e05ed02, + 0x7e05ee02, 0x7e05ef02, 0x7e05f002, 0x7e05f102, 0x7e05f202, 0x7e05f302, 0x7e05f402, 0x7e05f502, + 0x7e05f602, 0x7e05f702, 0x7e05f802, 0x7e05f902, 0x7e05fa02, 0x7e05fb02, 0x7e05fc02, 0x7e05fd02, + 0x7e05fe02, 0x7e05ff02, 0x7f050202, 0x7f050302, 0x7f050402, 0x7f050502, 0x7f050602, 0x7f050702, + 0x7f050802, 0x7f050902, 0x7f050a02, 0x7f050b02, 0x7f050c02, 0x7f050d02, 0x7f050e02, 0x7f050f02, + 0x7f051002, 0x7f051102, 0x7f051202, 0x7f051302, 0x7f051402, 0x7f051502, 0x7f051602, 0x7f051702, + 0x7f051802, 0x7f051902, 0x7f051a02, 0x7f051b02, 0x7f051c02, 0x7f051d02, 0x7f051e02, 0x7f051f02, + 0x7f052002, 0x7f052102, 0x7f052202, 0x7f052302, 0x7f052402, 0x7f052502, 0x7f052602, 0x7f052702, + 0x7f052802, 0x7f052902, 0x7f052a02, 0x7f052b02, 0x7f052c02, 0x7f052d02, 0x7f052e02, 0x7f052f02, + 0x7f053002, 0x7f053102, 0x7f053202, 0x7f053302, 0x7f053402, 0x7f053502, 0x7f053602, 0x7f053702, + 0x7f053802, 0x7f053902, 0x7f053a02, 0x7f053b02, 0x7f053c02, 0x7f053d02, 0x7f053e02, 0x7f053f02, + 0x7f054002, 0x7f054102, 0x7f054202, 0x7f054302, 0x7f054402, 0x7f054502, 0x7f054602, 0x7f054702, + 0x7f054802, 0x7f054902, 0x7f054a02, 0x7f054b02, 0x7f054c02, 0x7f054d02, 0x7f054e02, 0x7f054f02, + 0x7f055002, 0x7f055102, 0x7f055202, 0x7f055302, 0x7f055402, 0x7f055502, 0x7f055602, 0x7f055702, + 0x7f055802, 0x7f055902, 0x7f055a02, 0x7f055b02, 0x7f055c02, 0x7f055d02, 0x7f055e02, 0x7f055f02, + 0x7f056002, 0x7f056102, 0x7f056202, 0x7f056302, 0x7f056402, 0x7f056502, 0x7f056602, 0x7f056702, + 0x7f056802, 0x7f056902, 0x7f056a02, 0x7f056b02, 0x7f056c02, 0x7f056d02, 0x7f056e02, 0x7f056f02, + 0x7f057002, 0x7f057102, 0x7f057202, 0x7f057302, 0x7f057402, 0x7f057502, 0x7f057602, 0x7f057702, + 0x7f057802, 0x7f057902, 0x7f057a02, 0x7f057b02, 0x7f057c02, 0x7f057d02, 0x7f057e02, 0x7f057f02, + 0x7f058002, 0x7f058102, 0x7f058202, 0x7f058302, 0x7f058402, 0x7f058502, 0x7f058602, 0x7f058702, + 0x7f058802, 0x7f058902, 0x7f058a02, 0x7f058b02, 0x7f058c02, 0x7f058d02, 0x7f058e02, 0x7f058f02, + 0x7f059002, 0x7f059102, 0x7f059202, 0x7f059302, 0x7f059402, 0x7f059502, 0x7f059602, 0x7f059702, + 0x7f059802, 0x7f059902, 0x7f059a02, 0x7f059b02, 0x7f059c02, 0x7f059d02, 0x7f059e02, 0x7f059f02, + 0x7f05a002, 0x7f05a102, 0x7f05a202, 0x7f05a302, 0x7f05a402, 0x7f05a502, 0x7f05a602, 0x7f05a702, + 0x7f05a802, 0x7f05a902, 0x7f05aa02, 0x7f05ab02, 0x7f05ac02, 0x7f05ad02, 0x7f05ae02, 0x7f05af02, + 0x7f05b002, 0x7f05b102, 0x7f05b202, 0x7f05b302, 0x7f05b402, 0x7f05b502, 0x7f05b602, 0x7f05b702, + 0x7f05b802, 0x7f05b902, 0x7f05ba02, 0x7f05bb02, 0x7f05bc02, 0x7f05bd02, 0x7f05be02, 0x7f05bf02, + 0x7f05c002, 0x7f05c102, 0x7f05c202, 0x7f05c302, 0x7f05c402, 0x7f05c502, 0x7f05c602, 0x7f05c702, + 0x7f05c802, 0x7f05c902, 0x7f05ca02, 0x7f05cb02, 0x7f05cc02, 0x7f05cd02, 0x7f05ce02, 0x7f05cf02, + 0x7f05d002, 0x7f05d102, 0x7f05d202, 0x7f05d302, 0x7f05d402, 0x7f05d502, 0x7f05d602, 0x7f05d702, + 0x7f05d802, 0x7f05d902, 0x7f05da02, 0x7f05db02, 0x7f05dc02, 0x7f05dd02, 0x7f05de02, 0x7f05df02, + 0x7f05e002, 0x7f05e102, 0x7f05e202, 0x7f05e302, 0x7f05e402, 0x7f05e502, 0x7f05e602, 0x7f05e702, + 0x7f05e802, 0x7f05e902, 0x7f05ea02, 0x7f05eb02, 0x7f05ec02, 0x7f05ed02, 0x7f05ee02, 0x7f05ef02, + 0x7f05f002, 0x7f05f102, 0x7f05f202, 0x7f05f302, 0x7f05f402, 0x7f05f502, 0x7f05f602, 0x7f05f702, + 0x7f05f802, 0x7f05f902, 0x7f05fa02, 0x7f05fb02, 0x7f05fc02, 0x7f05fd02, 0x7f05fe02, 0x7f05ff02, + 0x80050202, 0x80050302, 0x80050402, 0x80050502, 0x80050602, 0x80050702, 0x80050802, 0x80050902, + 0x80050a02, 0x80050b02, 0x80050c02, 0x80050d02, 0x80050e02, 0x80050f02, 0x80051002, 0x80051102, + 0x80051202, 0x80051302, 0x80051402, 0x80051502, 0x80051602, 0x80051702, 0x80051802, 0x80051902, + 0x80051a02, 0x80051b02, 0x80051c02, 0x80051d02, 0x80051e02, 0x80051f02, 0x80052002, 0x80052102, + 0x80052202, 0x80052302, 0x80052402, 0x80052502, 0x80052602, 0x80052702, 0x80052802, 0x80052902, + 0x80052a02, 0x80052b02, 0x80052c02, 0x80052d02, 0x80052e02, 0x80052f02, 0x80053002, 0x80053102, + 0x80053202, 0x80053302, 0x80053402, 0x80053502, 0x80053602, 0x80053702, 0x80053802, 0x80053902, + 0x80053a02, 0x80053b02, 0x80053c02, 0x80053d02, 0x80053e02, 0x80053f02, 0x80054002, 0x80054102, + 0x80054202, 0x80054302, 0x80054402, 0x80054502, 0x80054602, 0x80054702, 0x80054802, 0x80054902, + 0x80054a02, 0x80054b02, 0x80054c02, 0x80054d02, 0x80054e02, 0x80054f02, 0x80055002, 0x80055102, + 0x80055202, 0x80055302, 0x80055402, 0x80055502, 0x80055602, 0x80055702, 0x80055802, 0x80055902, + 0x80055a02, 0x80055b02, 0x80055c02, 0x80055d02, 0x80055e02, 0x80055f02, 0x80056002, 0x80056102, + 0x80056202, 0x80056302, 0x80056402, 0x80056502, 0x80056602, 0x80056702, 0x80056802, 0x80056902, + 0x80056a02, 0x80056b02, 0x80056c02, 0x80056d02, 0x80056e02, 0x80056f02, 0x80057002, 0x80057102, + 0x80057202, 0x80057302, 0x80057402, 0x80057502, 0x80057602, 0x80057702, 0x80057802, 0x80057902, + 0x80057a02, 0x80057b02, 0x80057c02, 0x80057d02, 0x80057e02, 0x80057f02, 0x80058002, 0x80058102, + 0x80058202, 0x80058302, 0x80058402, 0x80058502, 0x80058602, 0x80058702, 0x80058802, 0x80058902, + 0x80058a02, 0x80058b02, 0x80058c02, 0x80058d02, 0x80058e02, 0x80058f02, 0x80059002, 0x80059102, + 0x80059202, 0x80059302, 0x80059402, 0x80059502, 0x80059602, 0x80059702, 0x80059802, 0x80059902, + 0x80059a02, 0x80059b02, 0x80059c02, 0x80059d02, 0x80059e02, 0x80059f02, 0x8005a002, 0x8005a102, + 0x8005a202, 0x8005a302, 0x8005a402, 0x8005a502, 0x8005a602, 0x8005a702, 0x8005a802, 0x8005a902, + 0x8005aa02, 0x8005ab02, 0x8005ac02, 0x8005ad02, 0x8005ae02, 0x8005af02, 0x8005b002, 0x8005b102, + 0x8005b202, 0x8005b302, 0x8005b402, 0x8005b502, 0x8005b602, 0x8005b702, 0x8005b802, 0x8005b902, + 0x8005ba02, 0x8005bb02, 0x8005bc02, 0x8005bd02, 0x8005be02, 0x8005bf02, 0x8005c002, 0x8005c102, + 0x8005c202, 0x8005c302, 0x8005c402, 0x8005c502, 0x8005c602, 0x8005c702, 0x8005c802, 0x8005c902, + 0x8005ca02, 0x8005cb02, 0x8005cc02, 0x8005cd02, 0x8005ce02, 0x8005cf02, 0x8005d002, 0x8005d102, + 0x8005d202, 0x8005d302, 0x8005d402, 0x8005d502, 0x8005d602, 0x8005d702, 0x8005d802, 0x8005d902, + 0x8005da02, 0x8005db02, 0x8005dc02, 0x8005dd02, 0x8005de02, 0x8005df02, 0x8005e002, 0x8005e102, + 0x8005e202, 0x8005e302, 0x8005e402, 0x8005e502, 0x8005e602, 0x8005e702, 0x8005e802, 0x8005e902, + 0x8005ea02, 0x8005eb02, 0x8005ec02, 0x8005ed02, 0x8005ee02, 0x8005ef02, 0x8005f002, 0x8005f102, + 0x8005f202, 0x8005f302, 0x8005f402, 0x8005f502, 0x8005f602, 0x8005f702, 0x8005f802, 0x8005f902, + 0x8005fa02, 0x8005fb02, 0x8005fc02, 0x8005fd02, 0x8005fe02, 0x8005ff02, 0x81050202, 0x81050302, + 0x81050402, 0x81050502, 0x81050602, 0x81050702, 0x81050802, 0x81050902, 0x81050a02, 0x81050b02, + 0x81050c02, 0x81050d02, 0x81050e02, 0x81050f02, 0x81051002, 0x81051102, 0x81051202, 0x81051302, + 0x81051402, 0x81051502, 0x81051602, 0x81051702, 0x81051802, 0x81051902, 0x81051a02, 0x81051b02, + 0x81051c02, 0x81051d02, 0x81051e02, 0x81051f02, 0x81052002, 0x81052102, 0x81052202, 0x81052302, + 0x81052402, 0x81052502, 0x81052602, 0x81052702, 0x81052802, 0x81052902, 0x81052a02, 0x81052b02, + 0x81052c02, 0x81052d02, 0x81052e02, 0x81052f02, 0x81053002, 0x81053102, 0x81053202, 0x81053302, + 0x81053402, 0x81053502, 0x81053602, 0x81053702, 0x81053802, 0x81053902, 0x81053a02, 0x81053b02, + 0x81053c02, 0x81053d02, 0x81053e02, 0x81053f02, 0x81054002, 0x81054102, 0x81054202, 0x81054302, + 0x81054402, 0x81054502, 0x81054602, 0x81054702, 0x81054802, 0x81054902, 0x81054a02, 0x81054b02, + 0x81054c02, 0x81054d02, 0x81054e02, 0x81054f02, 0x81055002, 0x81055102, 0x81055202, 0x81055302, + 0x81055402, 0x81055502, 0x81055602, 0x81055702, 0x81055802, 0x81055902, 0x81055a02, 0x81055b02, + 0x81055c02, 0x81055d02, 0x81055e02, 0x81055f02, 0x81056002, 0x81056102, 0x81056202, 0x81056302, + 0x81056402, 0x81056502, 0x81056602, 0x81056702, 0x81056802, 0x81056902, 0x81056a02, 0x81056b02, + 0x81056c02, 0x81056d02, 0x81056e02, 0x81056f02, 0x81057002, 0x81057102, 0x81057202, 0x81057302, + 0x81057402, 0x81057502, 0x81057602, 0x81057702, 0x81057802, 0x81057902, 0x81057a02, 0x81057b02, + 0x81057c02, 0x81057d02, 0x81057e02, 0x81057f02, 0x81058002, 0x81058102, 0x81058202, 0x81058302, + 0x81058402, 0x81058502, 0x81058602, 0x81058702, 0x81058802, 0x81058902, 0x81058a02, 0x81058b02, + 0x81058c02, 0x81058d02, 0x81058e02, 0x81058f02, 0x81059002, 0x81059102, 0x81059202, 0x81059302, + 0x81059402, 0x81059502, 0x81059602, 0x81059702, 0x81059802, 0x81059902, 0x81059a02, 0x81059b02, + 0x81059c02, 0x81059d02, 0x81059e02, 0x81059f02, 0x8105a002, 0x8105a102, 0x8105a202, 0x8105a302, + 0x8105a402, 0x8105a502, 0x8105a602, 0x8105a702, 0x8105a802, 0x8105a902, 0x8105aa02, 0x8105ab02, + 0x8105ac02, 0x8105ad02, 0x8105ae02, 0x8105af02, 0x8105b002, 0x8105b102, 0x8105b202, 0x8105b302, + 0x8105b402, 0x8105b502, 0x8105b602, 0x8105b702, 0x8105b802, 0x8105b902, 0x8105ba02, 0x8105bb02, + 0x8105bc02, 0x8105bd02, 0x8105be02, 0x8105bf02, 0x8105c002, 0x8105c102, 0x8105c202, 0x8105c302, + 0x8105c402, 0x8105c502, 0x8105c602, 0x8105c702, 0x8105c802, 0x8105c902, 0x8105ca02, 0x8105cb02, + 0x8105cc02, 0x8105cd02, 0x8105ce02, 0x8105cf02, 0x8105d002, 0x8105d102, 0x8105d202, 0x8105d302, + 0x8105d402, 0x8105d502, 0x8105d602, 0x8105d702, 0x8105d802, 0x8105d902, 0x8105da02, 0x8105db02, + 0x8105dc02, 0x8105dd02, 0x8105de02, 0x8105df02, 0x8105e002, 0x8105e102, 0x8105e202, 0x8105e302, + 0x8105e402, 0x8105e502, 0x8105e602, 0x8105e702, 0x8105e802, 0x8105e902, 0x8105ea02, 0x8105eb02, + 0x8105ec02, 0x8105ed02, 0x8105ee02, 0x8105ef02, 0x8105f002, 0x8105f102, 0x8105f202, 0x8105f302, + 0x8105f402, 0x8105f502, 0x8105f602, 0x8105f702, 0x8105f802, 0x8105f902, 0x8105fa02, 0x8105fb02, + 0x8105fc02, 0x8105fd02, 0x8105fe02, 0x8105ff02, 0x82050202, 0x82050302, 0x82050402, 0x82050502, + 0x82050602, 0x82050702, 0x82050802, 0x82050902, 0x82050a02, 0x82050b02, 0x82050c02, 0x82050d02, + 0x82050e02, 0x82050f02, 0x82051002, 0x82051102, 0x82051202, 0x82051302, 0x82051402, 0x82051502, + 0x82051602, 0x82051702, 0x82051802, 0x82051902, 0x82051a02, 0x82051b02, 0x82051c02, 0x82051d02, + 0x82051e02, 0x82051f02, 0x82052002, 0x82052102, 0x82052202, 0x82052302, 0x82052402, 0x82052502, + 0x82052602, 0x82052702, 0x82052802, 0x82052902, 0x82052a02, 0x82052b02, 0x82052c02, 0x82052d02, + 0x82052e02, 0x82052f02, 0x82053002, 0x82053102, 0x82053202, 0x82053302, 0x82053402, 0x82053502, + 0x82053602, 0x82053702, 0x82053802, 0x82053902, 0x82053a02, 0x82053b02, 0x82053c02, 0x82053d02, + 0x82053e02, 0x82053f02, 0x82054002, 0x82054102, 0x82054202, 0x82054302, 0x82054402, 0x82054502, + 0x82054602, 0x82054702, 0x82054802, 0x82054902, 0x82054a02, 0x82054b02, 0x82054c02, 0x82054d02, + 0x82054e02, 0x82054f02, 0x82055002, 0x82055102, 0x82055202, 0x82055302, 0x82055402, 0x82055502, + 0x82055602, 0x82055702, 0x82055802, 0x82055902, 0x82055a02, 0x82055b02, 0x82055c02, 0x82055d02, + 0x82055e02, 0x82055f02, 0x82056002, 0x82056102, 0x82056202, 0x82056302, 0x82056402, 0x82056502, + 0x82056602, 0x82056702, 0x82056802, 0x82056902, 0x82056a02, 0x82056b02, 0x82056c02, 0x82056d02, + 0x82056e02, 0x82056f02, 0x82057002, 0x82057102, 0x82057202, 0x82057302, 0x82057402, 0x82057502, + 0x82057602, 0x82057702, 0x82057802, 0x82057902, 0x82057a02, 0x82057b02, 0x82057c02, 0x82057d02, + 0x82057e02, 0x82057f02, 0x82058002, 0x82058102, 0x82058202, 0x82058302, 0x82058402, 0x82058502, + 0x82058602, 0x82058702, 0x82058802, 0x82058902, 0x82058a02, 0x82058b02, 0x82058c02, 0x82058d02, + 0x82058e02, 0x82058f02, 0x82059002, 0x82059102, 0x82059202, 0x82059302, 0x82059402, 0x82059502, + 0x82059602, 0x82059702, 0x82059802, 0x82059902, 0x82059a02, 0x82059b02, 0x82059c02, 0x82059d02, + 0x82059e02, 0x82059f02, 0x8205a002, 0x8205a102, 0x8205a202, 0x8205a302, 0x8205a402, 0x8205a502, + 0x8205a602, 0x8205a702, 0x8205a802, 0x8205a902, 0x8205aa02, 0x8205ab02, 0x8205ac02, 0x8205ad02, + 0x8205ae02, 0x8205af02, 0x8205b002, 0x8205b102, 0x8205b202, 0x8205b302, 0x8205b402, 0x8205b502, + 0x8205b602, 0x8205b702, 0x8205b802, 0x8205b902, 0x8205ba02, 0x8205bb02, 0x8205bc02, 0x8205bd02, + 0x8205be02, 0x8205bf02, 0x8205c002, 0x8205c102, 0x8205c202, 0x8205c302, 0x8205c402, 0x8205c502, + 0x8205c602, 0x8205c702, 0x8205c802, 0x8205c902, 0x8205ca02, 0x8205cb02, 0x8205cc02, 0x8205cd02, + 0x8205ce02, 0x8205cf02, 0x8205d002, 0x8205d102, 0x8205d202, 0x8205d302, 0x8205d402, 0x8205d502, + 0x8205d602, 0x8205d702, 0x8205d802, 0x8205d902, 0x8205da02, 0x8205db02, 0x8205dc02, 0x8205dd02, + 0x8205de02, 0x8205df02, 0x8205e002, 0x8205e102, 0x8205e202, 0x8205e302, 0x8205e402, 0x8205e502, + 0x8205e602, 0x8205e702, 0x8205e802, 0x8205e902, 0x8205ea02, 0x8205eb02, 0x8205ec02, 0x8205ed02, + 0x8205ee02, 0x8205ef02, 0x8205f002, 0x8205f102, 0x8205f202, 0x8205f302, 0x8205f402, 0x8205f502, + 0x8205f602, 0x8205f702, 0x8205f802, 0x8205f902, 0x8205fa02, 0x8205fb02, 0x8205fc02, 0x8205fd02, + 0x8205fe02, 0x8205ff02, 0x83050202, 0x83050302, 0x83050402, 0x83050502, 0x83050602, 0x83050702, + 0x83050802, 0x83050902, 0x83050a02, 0x83050b02, 0x83050c02, 0x83050d02, 0x83050e02, 0x83050f02, + 0x83051002, 0x83051102, 0x83051202, 0x83051302, 0x83051402, 0x83051502, 0x83051602, 0x83051702, + 0x83051802, 0x83051902, 0x83051a02, 0x83051b02, 0x83051c02, 0x83051d02, 0x83051e02, 0x83051f02, + 0x83052002, 0x83052102, 0x83052202, 0x83052302, 0x83052402, 0x83052502, 0x83052602, 0x83052702, + 0x83052802, 0x83052902, 0x83052a02, 0x83052b02, 0x83052c02, 0x83052d02, 0x83052e02, 0x83052f02, + 0x83053002, 0x83053102, 0x83053202, 0x83053302, 0x83053402, 0x83053502, 0x83053602, 0x83053702, + 0x83053802, 0x83053902, 0x83053a02, 0x83053b02, 0x83053c02, 0x83053d02, 0x83053e02, 0x83053f02, + 0x83054002, 0x83054102, 0x83054202, 0x83054302, 0x83054402, 0x83054502, 0x83054602, 0x83054702, + 0x83054802, 0x83054902, 0x83054a02, 0x83054b02, 0x83054c02, 0x83054d02, 0x83054e02, 0x83054f02, + 0x83055002, 0x83055102, 0x83055202, 0x83055302, 0x83055402, 0x83055502, 0x83055602, 0x83055702, + 0x83055802, 0x83055902, 0x83055a02, 0x83055b02, 0x83055c02, 0x83055d02, 0x83055e02, 0x83055f02, + 0x83056002, 0x83056102, 0x83056202, 0x83056302, 0x83056402, 0x83056502, 0x83056602, 0x83056702, + 0x83056802, 0x83056902, 0x83056a02, 0x83056b02, 0x83056c02, 0x83056d02, 0x83056e02, 0x83056f02, + 0x83057002, 0x83057102, 0x83057202, 0x83057302, 0x83057402, 0x83057502, 0x83057602, 0x83057702, + 0x83057802, 0x83057902, 0x83057a02, 0x83057b02, 0x83057c02, 0x83057d02, 0x83057e02, 0x83057f02, + 0x83058002, 0x83058102, 0x83058202, 0x83058302, 0x83058402, 0x83058502, 0x83058602, 0x83058702, + 0x83058802, 0x83058902, 0x83058a02, 0x83058b02, 0x83058c02, 0x83058d02, 0x83058e02, 0x83058f02, + 0x83059002, 0x83059102, 0x83059202, 0x83059302, 0x83059402, 0x83059502, 0x83059602, 0x83059702, + 0x83059802, 0x83059902, 0x83059a02, 0x83059b02, 0x83059c02, 0x83059d02, 0x83059e02, 0x83059f02, + 0x8305a002, 0x8305a102, 0x8305a202, 0x8305a302, 0x8305a402, 0x8305a502, 0x8305a602, 0x8305a702, + 0x8305a802, 0x8305a902, 0x8305aa02, 0x8305ab02, 0x8305ac02, 0x8305ad02, 0x8305ae02, 0x8305af02, + 0x8305b002, 0x8305b102, 0x8305b202, 0x8305b302, 0x8305b402, 0x8305b502, 0x8305b602, 0x8305b702, + 0x8305b802, 0x8305b902, 0x8305ba02, 0x8305bb02, 0x8305bc02, 0x8305bd02, 0x8305be02, 0x8305bf02, + 0x8305c002, 0x8305c102, 0x8305c202, 0x8305c302, 0x8305c402, 0x8305c502, 0x8305c602, 0x8305c702, + 0x8305c802, 0x8305c902, 0x8305ca02, 0x8305cb02, 0x8305cc02, 0x8305cd02, 0x8305ce02, 0x8305cf02, + 0x8305d002, 0x8305d102, 0x8305d202, 0x8305d302, 0x8305d402, 0x8305d502, 0x8305d602, 0x8305d702, + 0x8305d802, 0x8305d902, 0x8305da02, 0x8305db02, 0x8305dc02, 0x8305dd02, 0x8305de02, 0x8305df02, + 0x8305e002, 0x8305e102, 0x8305e202, 0x8305e302, 0x8305e402, 0x8305e502, 0x8305e602, 0x8305e702, + 0x8305e802, 0x8305e902, 0x8305ea02, 0x8305eb02, 0x8305ec02, 0x8305ed02, 0x8305ee02, 0x8305ef02, + 0x8305f002, 0x8305f102, 0x8305f202, 0x8305f302, 0x8305f402, 0x8305f502, 0x8305f602, 0x8305f702, + 0x8305f802, 0x8305f902, 0x8305fa02, 0x8305fb02, 0x8305fc02, 0x8305fd02, 0x8305fe02, 0x8305ff02, + 0x84050202, 0x84050302, 0x84050402, 0x84050502, 0x84050602, 0x84050702, 0x84050802, 0x84050902, + 0x84050a02, 0x84050b02, 0x84050c02, 0x84050d02, 0x84050e02, 0x84050f02, 0x84051002, 0x84051102, + 0x84051202, 0x84051302, 0x84051402, 0x84051502, 0x84051602, 0x84051702, 0x84051802, 0x84051902, + 0x84051a02, 0x84051b02, 0x84051c02, 0x84051d02, 0x84051e02, 0x84051f02, 0x84052002, 0x84052102, + 0x84052202, 0x84052302, 0x84052402, 0x84052502, 0x84052602, 0x84052702, 0x84052802, 0x84052902, + 0x84052a02, 0x84052b02, 0x84052c02, 0x84052d02, 0x84052e02, 0x84052f02, 0x84053002, 0x84053102, + 0x84053202, 0x84053302, 0x84053402, 0x84053502, 0x84053602, 0x84053702, 0x84053802, 0x84053902, + 0x84053a02, 0x84053b02, 0x84053c02, 0x84053d02, 0x84053e02, 0x84053f02, 0x84054002, 0x84054102, + 0x84054202, 0x84054302, 0x84054402, 0x84054502, 0x84054602, 0x84054702, 0x84054802, 0x84054902, + 0x84054a02, 0x84054b02, 0x84054c02, 0x84054d02, 0x84054e02, 0x84054f02, 0x84055002, 0x84055102, + 0x84055202, 0x84055302, 0x84055402, 0x84055502, 0x84055602, 0x84055702, 0x84055802, 0x84055902, + 0x84055a02, 0x84055b02, 0x84055c02, 0x84055d02, 0x84055e02, 0x84055f02, 0x84056002, 0x84056102, + 0x84056202, 0x84056302, 0x84056402, 0x84056502, 0x84056602, 0x84056702, 0x84056802, 0x84056902, + 0x84056a02, 0x84056b02, 0x84056c02, 0x84056d02, 0x84056e02, 0x84056f02, 0x84057002, 0x84057102, + 0x84057202, 0x84057302, 0x84057402, 0x84057502, 0x84057602, 0x84057702, 0x84057802, 0x84057902, + 0x84057a02, 0x84057b02, 0x84057c02, 0x84057d02, 0x84057e02, 0x84057f02, 0x84058002, 0x84058102, + 0x84058202, 0x84058302, 0x84058402, 0x84058502, 0x84058602, 0x84058702, 0x84058802, 0x84058902, + 0x84058a02, 0x84058b02, 0x84058c02, 0x84058d02, 0x84058e02, 0x84058f02, 0x84059002, 0x84059102, + 0x84059202, 0x84059302, 0x84059402, 0x84059502, 0x84059602, 0x84059702, 0x84059802, 0x84059902, + 0x84059a02, 0x84059b02, 0x84059c02, 0x84059d02, 0x84059e02, 0x84059f02, 0x8405a002, 0x8405a102, + 0x8405a202, 0x8405a302, 0x8405a402, 0x8405a502, 0x8405a602, 0x8405a702, 0x8405a802, 0x8405a902, + 0x8405aa02, 0x8405ab02, 0x8405ac02, 0x8405ad02, 0x8405ae02, 0x8405af02, 0x8405b002, 0x8405b102, + 0x8405b202, 0x8405b302, 0x8405b402, 0x8405b502, 0x8405b602, 0x8405b702, 0x8405b802, 0x8405b902, + 0x8405ba02, 0x8405bb02, 0x8405bc02, 0x8405bd02, 0x8405be02, 0x8405bf02, 0x8405c002, 0x8405c102, + 0x8405c202, 0x8405c302, 0x8405c402, 0x8405c502, 0x8405c602, 0x8405c702, 0x8405c802, 0x8405c902, + 0x8405ca02, 0x8405cb02, 0x8405cc02, 0x8405cd02, 0x8405ce02, 0x8405cf02, 0x8405d002, 0x8405d102, + 0x8405d202, 0x8405d302, 0x8405d402, 0x8405d502, 0x8405d602, 0x8405d702, 0x8405d802, 0x8405d902, + 0x8405da02, 0x8405db02, 0x8405dc02, 0x8405dd02, 0x8405de02, 0x8405df02, 0x8405e002, 0x8405e102, + 0x8405e202, 0x8405e302, 0x8405e402, 0x8405e502, 0x8405e602, 0x8405e702, 0x8405e802, 0x8405e902, + 0x8405ea02, 0x8405eb02, 0x8405ec02, 0x8405ed02, 0x8405ee02, 0x8405ef02, 0x8405f002, 0x8405f102, + 0x8405f202, 0x8405f302, 0x8405f402, 0x8405f502, 0x8405f602, 0x8405f702, 0x8405f802, 0x8405f902, + 0x8405fa02, 0x8405fb02, 0x8405fc02, 0x8405fd02, 0x8405fe02, 0x8405ff02, 0x85050202, 0x85050302, + 0x85050402, 0x85050502, 0x85050602, 0x85050702, 0x85050802, 0x85050902, 0x85050a02, 0x85050b02, + 0x85050c02, 0x85050d02, 0x85050e02, 0x85050f02, 0x85051002, 0x85051102, 0x85051202, 0x85051302, + 0x85051402, 0x85051502, 0x85051602, 0x85051702, 0x85051802, 0x85051902, 0x85051a02, 0x85051b02, + 0x85051c02, 0x85051d02, 0x85051e02, 0x85051f02, 0x85052002, 0x85052102, 0x85052202, 0x85052302, + 0x85052402, 0x85052502, 0x85052602, 0x85052702, 0x85052802, 0x85052902, 0x85052a02, 0x85052b02, + 0x85052c02, 0x85052d02, 0x85052e02, 0x85052f02, 0x85053002, 0x85053102, 0x85053202, 0x85053302, + 0x85053402, 0x85053502, 0x85053602, 0x85053702, 0x85053802, 0x85053902, 0x85053a02, 0x85053b02, + 0x85053c02, 0x85053d02, 0x85053e02, 0x85053f02, 0x85054002, 0x85054102, 0x85054202, 0x85054302, + 0x85054402, 0x85054502, 0x85054602, 0x85054702, 0x85054802, 0x85054902, 0x85054a02, 0x85054b02, + 0x85054c02, 0x85054d02, 0x85054e02, 0x85054f02, 0x85055002, 0x85055102, 0x85055202, 0x85055302, + 0x85055402, 0x85055502, 0x85055602, 0x85055702, 0x85055802, 0x85055902, 0x85055a02, 0x85055b02, + 0x85055c02, 0x85055d02, 0x85055e02, 0x85055f02, 0x85056002, 0x85056102, 0x85056202, 0x85056302, + 0x85056402, 0x85056502, 0x85056602, 0x85056702, 0x85056802, 0x85056902, 0x85056a02, 0x85056b02, + 0x85056c02, 0x85056d02, 0x85056e02, 0x85056f02, 0x85057002, 0x85057102, 0x85057202, 0x85057302, + 0x85057402, 0x85057502, 0x85057602, 0x85057702, 0x85057802, 0x85057902, 0x85057a02, 0x85057b02, + 0x85057c02, 0x85057d02, 0x85057e02, 0x85057f02, 0x85058002, 0x85058102, 0x85058202, 0x85058302, + 0x85058402, 0x85058502, 0x85058602, 0x85058702, 0x85058802, 0x85058902, 0x85058a02, 0x85058b02, + 0x85058c02, 0x85058d02, 0x85058e02, 0x85058f02, 0x85059002, 0x85059102, 0x85059202, 0x85059302, + 0x85059402, 0x85059502, 0x85059602, 0x85059702, 0x85059802, 0x85059902, 0x85059a02, 0x85059b02, + 0x85059c02, 0x85059d02, 0x85059e02, 0x85059f02, 0x8505a002, 0x8505a102, 0x8505a202, 0x8505a302, + 0x8505a402, 0x8505a502, 0x8505a602, 0x8505a702, 0x8505a802, 0x8505a902, 0x8505aa02, 0x8505ab02, + 0x8505ac02, 0x8505ad02, 0x8505ae02, 0x8505af02, 0x8505b002, 0x8505b102, 0x8505b202, 0x8505b302, + 0x8505b402, 0x8505b502, 0x8505b602, 0x8505b702, 0x8505b802, 0x8505b902, 0x8505ba02, 0x8505bb02, + 0x8505bc02, 0x8505bd02, 0x8505be02, 0x8505bf02, 0x8505c002, 0x8505c102, 0x8505c202, 0x8505c302, + 0x8505c402, 0x8505c502, 0x8505c602, 0x8505c702, 0x8505c802, 0x8505c902, 0x8505ca02, 0x8505cb02, + 0x8505cc02, 0x8505cd02, 0x8505ce02, 0x8505cf02, 0x8505d002, 0x8505d102, 0x8505d202, 0x8505d302, + 0x8505d402, 0x8505d502, 0x8505d602, 0x8505d702, 0x8505d802, 0x8505d902, 0x8505da02, 0x8505db02, + 0x8505dc02, 0x8505dd02, 0x8505de02, 0x8505df02, 0x8505e002, 0x8505e102, 0x8505e202, 0x8505e302, + 0x8505e402, 0x8505e502, 0x8505e602, 0x8505e702, 0x8505e802, 0x8505e902, 0x8505ea02, 0x8505eb02, + 0x8505ec02, 0x8505ed02, 0x8505ee02, 0x8505ef02, 0x8505f002, 0x8505f102, 0x8505f202, 0x8505f302, + 0x8505f402, 0x8505f502, 0x8505f602, 0x8505f702, 0x8505f802, 0x8505f902, 0x8505fa02, 0x8505fb02, + 0x8505fc02, 0x8505fd02, 0x8505fe02, 0x8505ff02, 0x86050202, 0x86050302, 0x86050402, 0x86050502, + 0x86050602, 0x86050702, 0x86050802, 0x86050902, 0x86050a02, 0x86050b02, 0x86050c02, 0x86050d02, + 0x86050e02, 0x86050f02, 0x86051002, 0x86051102, 0x86051202, 0x86051302, 0x86051402, 0x86051502, + 0x86051602, 0x86051702, 0x86051802, 0x86051902, 0x86051a02, 0x86051b02, 0x86051c02, 0x86051d02, + 0x86051e02, 0x86051f02, 0x86052002, 0x86052102, 0x86052202, 0x86052302, 0x86052402, 0x86052502, + 0x86052602, 0x86052702, 0x86052802, 0x86052902, 0x86052a02, 0x86052b02, 0x86052c02, 0x86052d02, + 0x86052e02, 0x86052f02, 0x86053002, 0x86053102, 0x86053202, 0x86053302, 0x86053402, 0x86053502, + 0x86053602, 0x86053702, 0x86053802, 0x86053902, 0x86053a02, 0x86053b02, 0x86053c02, 0x86053d02, + 0x86053e02, 0x86053f02, 0x86054002, 0x86054102, 0x86054202, 0x86054302, 0x86054402, 0x86054502, + 0x86054602, 0x86054702, 0x86054802, 0x86054902, 0x86054a02, 0x86054b02, 0x86054c02, 0x86054d02, + 0x86054e02, 0x86054f02, 0x86055002, 0x86055102, 0x86055202, 0x86055302, 0x86055402, 0x86055502, + 0x86055602, 0x86055702, 0x86055802, 0x86055902, 0x86055a02, 0x86055b02, 0x86055c02, 0x86055d02, + 0x86055e02, 0x86055f02, 0x86056002, 0x86056102, 0x86056202, 0x86056302, 0x86056402, 0x86056502, + 0x86056602, 0x86056702, 0x86056802, 0x86056902, 0x86056a02, 0x86056b02, 0x86056c02, 0x86056d02, + 0x86056e02, 0x86056f02, 0x86057002, 0x86057102, 0x86057202, 0x86057302, 0x86057402, 0x86057502, + 0x86057602, 0x86057702, 0x86057802, 0x86057902, 0x86057a02, 0x86057b02, 0x86057c02, 0x86057d02, + 0x86057e02, 0x86057f02, 0x86058002, 0x86058102, 0x86058202, 0x86058302, 0x86058402, 0x86058502, + 0x86058602, 0x86058702, 0x86058802, 0x86058902, 0x86058a02, 0x86058b02, 0x86058c02, 0x86058d02, + 0x86058e02, 0x86058f02, 0x86059002, 0x86059102, 0x86059202, 0x86059302, 0x86059402, 0x86059502, + 0x86059602, 0x86059702, 0x86059802, 0x86059902, 0x86059a02, 0x86059b02, 0x86059c02, 0x86059d02, + 0x86059e02, 0x86059f02, 0x8605a002, 0x8605a102, 0x8605a202, 0x8605a302, 0x8605a402, 0x8605a502, + 0x8605a602, 0x8605a702, 0x8605a802, 0x8605a902, 0x8605aa02, 0x8605ab02, 0x8605ac02, 0x8605ad02, + 0x8605ae02, 0x8605af02, 0x8605b002, 0x8605b102, 0x8605b202, 0x8605b302, 0x8605b402, 0x8605b502, + 0x8605b602, 0x8605b702, 0x8605b802, 0x8605b902, 0x8605ba02, 0x8605bb02, 0x8605bc02, 0x8605bd02, + 0x8605be02, 0x8605bf02, 0x8605c002, 0x8605c102, 0x8605c202, 0x8605c302, 0x8605c402, 0x8605c502, + 0x8605c602, 0x8605c702, 0x8605c802, 0x8605c902, 0x8605ca02, 0x8605cb02, 0x8605cc02, 0x8605cd02, + 0x8605ce02, 0x8605cf02, 0x8605d002, 0x8605d102, 0x8605d202, 0x8605d302, 0x8605d402, 0x8605d502, + 0x8605d602, 0x8605d702, 0x8605d802, 0x8605d902, 0x8605da02, 0x8605db02, 0x8605dc02, 0x8605dd02, + 0x8605de02, 0x8605df02, 0x8605e002, 0x8605e102, 0x8605e202, 0x8605e302, 0x8605e402, 0x8605e502, + 0x8605e602, 0x8605e702, 0x8605e802, 0x8605e902, 0x8605ea02, 0x8605eb02, 0x8605ec02, 0x8605ed02, + 0x8605ee02, 0x8605ef02, 0x8605f002, 0x8605f102, 0x8605f202, 0x8605f302, 0x8605f402, 0x8605f502, + 0x8605f602, 0x8605f702, 0x8605f802, 0x8605f902, 0x8605fa02, 0x8605fb02, 0x8605fc02, 0x8605fd02, + 0x8605fe02, 0x8605ff02, 0x87050202, 0x87050302, 0x87050402, 0x87050502, 0x87050602, 0x87050702, + 0x87050802, 0x87050902, 0x87050a02, 0x87050b02, 0x87050c02, 0x87050d02, 0x87050e02, 0x87050f02, + 0x87051002, 0x87051102, 0x87051202, 0x87051302, 0x87051402, 0x87051502, 0x87051602, 0x87051702, + 0x87051802, 0x87051902, 0x87051a02, 0x87051b02, 0x87051c02, 0x87051d02, 0x87051e02, 0x87051f02, + 0x87052002, 0x87052102, 0x87052202, 0x87052302, 0x87052402, 0x87052502, 0x87052602, 0x87052702, + 0x87052802, 0x87052902, 0x87052a02, 0x87052b02, 0x87052c02, 0x87052d02, 0x87052e02, 0x87052f02, + 0x87053002, 0x87053102, 0x87053202, 0x87053302, 0x87053402, 0x87053502, 0x87053602, 0x87053702, + 0x87053802, 0x87053902, 0x87053a02, 0x87053b02, 0x87053c02, 0x87053d02, 0x87053e02, 0x87053f02, + 0x87054002, 0x87054102, 0x87054202, 0x87054302, 0x87054402, 0x87054502, 0x87054602, 0x87054702, + 0x87054802, 0x87054902, 0x87054a02, 0x87054b02, 0x87054c02, 0x87054d02, 0x87054e02, 0x87054f02, + 0x87055002, 0x87055102, 0x87055202, 0x87055302, 0x87055402, 0x87055502, 0x87055602, 0x87055702, + 0x87055802, 0x87055902, 0x87055a02, 0x87055b02, 0x87055c02, 0x87055d02, 0x87055e02, 0x87055f02, + 0x87056002, 0x87056102, 0x87056202, 0x87056302, 0x87056402, 0x87056502, 0x87056602, 0x87056702, + 0x87056802, 0x87056902, 0x87056a02, 0x87056b02, 0x87056c02, 0x87056d02, 0x87056e02, 0x87056f02, + 0x87057002, 0x87057102, 0x87057202, 0x87057302, 0x87057402, 0x87057502, 0x87057602, 0x87057702, + 0x87057802, 0x87057902, 0x87057a02, 0x87057b02, 0x87057c02, 0x87057d02, 0x87057e02, 0x87057f02, + 0x87058002, 0x87058102, 0x87058202, 0x87058302, 0x87058402, 0x87058502, 0x87058602, 0x87058702, + 0x87058802, 0x87058902, 0x87058a02, 0x87058b02, 0x87058c02, 0x87058d02, 0x87058e02, 0x87058f02, + 0x87059002, 0x87059102, 0x87059202, 0x87059302, 0x87059402, 0x87059502, 0x87059602, 0x87059702, + 0x87059802, 0x87059902, 0x87059a02, 0x87059b02, 0x87059c02, 0x87059d02, 0x87059e02, 0x87059f02, + 0x8705a002, 0x8705a102, 0x8705a202, 0x8705a302, 0x8705a402, 0x8705a502, 0x8705a602, 0x8705a702, + 0x8705a802, 0x8705a902, 0x8705aa02, 0x8705ab02, 0x8705ac02, 0x8705ad02, 0x8705ae02, 0x8705af02, + 0x8705b002, 0x8705b102, 0x8705b202, 0x8705b302, 0x8705b402, 0x8705b502, 0x8705b602, 0x8705b702, + 0x8705b802, 0x8705b902, 0x8705ba02, 0x8705bb02, 0x8705bc02, 0x8705bd02, 0x8705be02, 0x8705bf02, + 0x8705c002, 0x8705c102, 0x8705c202, 0x8705c302, 0x8705c402, 0x8705c502, 0x8705c602, 0x8705c702, + 0x8705c802, 0x8705c902, 0x8705ca02, 0x8705cb02, 0x8705cc02, 0x8705cd02, 0x8705ce02, 0x8705cf02, + 0x8705d002, 0x8705d102, 0x8705d202, 0x8705d302, 0x8705d402, 0x8705d502, 0x8705d602, 0x8705d702, + 0x8705d802, 0x8705d902, 0x8705da02, 0x8705db02, 0x8705dc02, 0x8705dd02, 0x8705de02, 0x8705df02, + 0x8705e002, 0x8705e102, 0x8705e202, 0x8705e302, 0x8705e402, 0x8705e502, 0x8705e602, 0x8705e702, + 0x8705e802, 0x8705e902, 0x8705ea02, 0x8705eb02, 0x8705ec02, 0x8705ed02, 0x8705ee02, 0x8705ef02, + 0x8705f002, 0x8705f102, 0x8705f202, 0x8705f302, 0x8705f402, 0x8705f502, 0x8705f602, 0x8705f702, + 0x8705f802, 0x8705f902, 0x8705fa02, 0x8705fb02, 0x8705fc02, 0x8705fd02, 0x8705fe02, 0x8705ff02, + 0x88050202, 0x88050302, 0x88050402, 0x88050502, 0x88050602, 0x88050702, 0x88050802, 0x88050902, + 0x88050a02, 0x88050b02, 0x88050c02, 0x88050d02, 0x88050e02, 0x88050f02, 0x88051002, 0x88051102, + 0x88051202, 0x88051302, 0x88051402, 0x88051502, 0x88051602, 0x88051702, 0x88051802, 0x88051902, + 0x88051a02, 0x88051b02, 0x88051c02, 0x88051d02, 0x88051e02, 0x88051f02, 0x88052002, 0x88052102, + 0x88052202, 0x88052302, 0x88052402, 0x88052502, 0x88052602, 0x88052702, 0x88052802, 0x88052902, + 0x88052a02, 0x88052b02, 0x88052c02, 0x88052d02, 0x88052e02, 0x88052f02, 0x88053002, 0x88053102, + 0x88053202, 0x88053302, 0x88053402, 0x88053502, 0x88053602, 0x88053702, 0x88053802, 0x88053902, + 0x88053a02, 0x88053b02, 0x88053c02, 0x88053d02, 0x88053e02, 0x88053f02, 0x88054002, 0x88054102, + 0x88054202, 0x88054302, 0x88054402, 0x88054502, 0x88054602, 0x88054702, 0x88054802, 0x88054902, + 0x88054a02, 0x88054b02, 0x88054c02, 0x88054d02, 0x88054e02, 0x88054f02, 0x88055002, 0x88055102, + 0x88055202, 0x88055302, 0x88055402, 0x88055502, 0x88055602, 0x88055702, 0x88055802, 0x88055902, + 0x88055a02, 0x88055b02, 0x88055c02, 0x88055d02, 0x88055e02, 0x88055f02, 0x88056002, 0x88056102, + 0x88056202, 0x88056302, 0x88056402, 0x88056502, 0x88056602, 0x88056702, 0x88056802, 0x88056902, + 0x88056a02, 0x88056b02, 0x88056c02, 0x88056d02, 0x88056e02, 0x88056f02, 0x88057002, 0x88057102, + 0x88057202, 0x88057302, 0x88057402, 0x88057502, 0x88057602, 0x88057702, 0x88057802, 0x88057902, + 0x88057a02, 0x88057b02, 0x88057c02, 0x88057d02, 0x88057e02, 0x88057f02, 0x88058002, 0x88058102, + 0x88058202, 0x88058302, 0x88058402, 0x88058502, 0x88058602, 0x88058702, 0x88058802, 0x88058902, + 0x88058a02, 0x88058b02, 0x88058c02, 0x88058d02, 0x88058e02, 0x88058f02, 0x88059002, 0x88059102, + 0x88059202, 0x88059302, 0x88059402, 0x88059502, 0x88059602, 0x88059702, 0x88059802, 0x88059902, + 0x88059a02, 0x88059b02, 0x88059c02, 0x88059d02, 0x88059e02, 0x88059f02, 0x8805a002, 0x8805a102, + 0x8805a202, 0x8805a302, 0x8805a402, 0x8805a502, 0x8805a602, 0x8805a702, 0x8805a802, 0x8805a902, + 0x8805aa02, 0x8805ab02, 0x8805ac02, 0x8805ad02, 0x8805ae02, 0x8805af02, 0x8805b002, 0x8805b102, + 0x8805b202, 0x8805b302, 0x8805b402, 0x8805b502, 0x8805b602, 0x8805b702, 0x8805b802, 0x8805b902, + 0x8805ba02, 0x8805bb02, 0x8805bc02, 0x8805bd02, 0x8805be02, 0x8805bf02, 0x8805c002, 0x8805c102, + 0x8805c202, 0x8805c302, 0x8805c402, 0x8805c502, 0x8805c602, 0x8805c702, 0x8805c802, 0x8805c902, + 0x8805ca02, 0x8805cb02, 0x8805cc02, 0x8805cd02, 0x8805ce02, 0x8805cf02, 0x8805d002, 0x8805d102, + 0x8805d202, 0x8805d302, 0x8805d402, 0x8805d502, 0x8805d602, 0x8805d702, 0x8805d802, 0x8805d902, + 0x8805da02, 0x8805db02, 0x8805dc02, 0x8805dd02, 0x8805de02, 0x8805df02, 0x8805e002, 0x8805e102, + 0x8805e202, 0x8805e302, 0x8805e402, 0x8805e502, 0x8805e602, 0x8805e702, 0x8805e802, 0x8805e902, + 0x8805ea02, 0x8805eb02, 0x8805ec02, 0x8805ed02, 0x8805ee02, 0x8805ef02, 0x8805f002, 0x8805f102, + 0x8805f202, 0x8805f302, 0x8805f402, 0x8805f502, 0x8805f602, 0x8805f702, 0x8805f802, 0x8805f902, + 0x8805fa02, 0x8805fb02, 0x8805fc02, 0x8805fd02, 0x8805fe02, 0x8805ff02, 0x89050202, 0x89050302, + 0x89050402, 0x89050502, 0x89050602, 0x89050702, 0x89050802, 0x89050902, 0x89050a02, 0x89050b02, + 0x89050c02, 0x89050d02, 0x89050e02, 0x89050f02, 0x89051002, 0x89051102, 0x89051202, 0x89051302, + 0x89051402, 0x89051502, 0x89051602, 0x89051702, 0x89051802, 0x89051902, 0x89051a02, 0x89051b02, + 0x89051c02, 0x89051d02, 0x89051e02, 0x89051f02, 0x89052002, 0x89052102, 0x89052202, 0x89052302, + 0x89052402, 0x89052502, 0x89052602, 0x89052702, 0x89052802, 0x89052902, 0x89052a02, 0x89052b02, + 0x89052c02, 0x89052d02, 0x89052e02, 0x89052f02, 0x89053002, 0x89053102, 0x89053202, 0x89053302, + 0x89053402, 0x89053502, 0x89053602, 0x89053702, 0x89053802, 0x89053902, 0x89053a02, 0x89053b02, + 0x89053c02, 0x89053d02, 0x89053e02, 0x89053f02, 0x89054002, 0x89054102, 0x89054202, 0x89054302, + 0x89054402, 0x89054502, 0x89054602, 0x89054702, 0x89054802, 0x89054902, 0x89054a02, 0x89054b02, + 0x89054c02, 0x89054d02, 0x89054e02, 0x89054f02, 0x89055002, 0x89055102, 0x89055202, 0x89055302, + 0x89055402, 0x89055502, 0x89055602, 0x89055702, 0x89055802, 0x89055902, 0x89055a02, 0x89055b02, + 0x89055c02, 0x89055d02, 0x89055e02, 0x89055f02, 0x89056002, 0x89056102, 0x89056202, 0x89056302, + 0x89056402, 0x89056502, 0x89056602, 0x89056702, 0x89056802, 0x89056902, 0x89056a02, 0x89056b02, + 0x89056c02, 0x89056d02, 0x89056e02, 0x89056f02, 0x89057002, 0x89057102, 0x89057202, 0x89057302, + 0x89057402, 0x89057502, 0x89057602, 0x89057702, 0x89057802, 0x89057902, 0x89057a02, 0x89057b02, + 0x89057c02, 0x89057d02, 0x89057e02, 0x89057f02, 0x89058002, 0x89058102, 0x89058202, 0x89058302, + 0x89058402, 0x89058502, 0x89058602, 0x89058702, 0x89058802, 0x89058902, 0x89058a02, 0x89058b02, + 0x89058c02, 0x89058d02, 0x89058e02, 0x89058f02, 0x89059002, 0x89059102, 0x89059202, 0x89059302, + 0x89059402, 0x89059502, 0x89059602, 0x89059702, 0x89059802, 0x89059902, 0x89059a02, 0x89059b02, + 0x89059c02, 0x89059d02, 0x89059e02, 0x89059f02, 0x8905a002, 0x8905a102, 0x8905a202, 0x8905a302, + 0x8905a402, 0x8905a502, 0x8905a602, 0x8905a702, 0x8905a802, 0x8905a902, 0x8905aa02, 0x8905ab02, + 0x8905ac02, 0x8905ad02, 0x8905ae02, 0x8905af02, 0x8905b002, 0x8905b102, 0x8905b202, 0x8905b302, + 0x8905b402, 0x8905b502, 0x8905b602, 0x8905b702, 0x8905b802, 0x8905b902, 0x8905ba02, 0x8905bb02, + 0x8905bc02, 0x8905bd02, 0x8905be02, 0x8905bf02, 0x8905c002, 0x8905c102, 0x8905c202, 0x8905c302, + 0x8905c402, 0x8905c502, 0x8905c602, 0x8905c702, 0x8905c802, 0x8905c902, 0x8905ca02, 0x8905cb02, + 0x8905cc02, 0x8905cd02, 0x8905ce02, 0x8905cf02, 0x8905d002, 0x8905d102, 0x8905d202, 0x8905d302, + 0x8905d402, 0x8905d502, 0x8905d602, 0x8905d702, 0x8905d802, 0x8905d902, 0x8905da02, 0x8905db02, + 0x8905dc02, 0x8905dd02, 0x8905de02, 0x8905df02, 0x8905e002, 0x8905e102, 0x8905e202, 0x8905e302, + 0x8905e402, 0x8905e502, 0x8905e602, 0x8905e702, 0x8905e802, 0x8905e902, 0x8905ea02, 0x8905eb02, + 0x8905ec02, 0x8905ed02, 0x8905ee02, 0x8905ef02, 0x8905f002, 0x8905f102, 0x8905f202, 0x8905f302, + 0x8905f402, 0x8905f502, 0x8905f602, 0x8905f702, 0x8905f802, 0x8905f902, 0x8905fa02, 0x8905fb02, + 0x8905fc02, 0x8905fd02, 0x8905fe02, 0x8905ff02, 0x8a050202, 0x8a050302, 0x8a050402, 0x8a050502, + 0x8a050602, 0x8a050702, 0x8a050802, 0x8a050902, 0x8a050a02, 0x8a050b02, 0x8a050c02, 0x8a050d02, + 0x8a050e02, 0x8a050f02, 0x8a051002, 0x8a051102, 0x8a051202, 0x8a051302, 0x8a051402, 0x8a051502, + 0x8a051602, 0x8a051702, 0x8a051802, 0x8a051902, 0x8a051a02, 0x8a051b02, 0x8a051c02, 0x8a051d02, + 0x8a051e02, 0x8a051f02, 0x8a052002, 0x8a052102, 0x8a052202, 0x8a052302, 0x8a052402, 0x8a052502, + 0x8a052602, 0x8a052702, 0x8a052802, 0x8a052902, 0x8a052a02, 0x8a052b02, 0x8a052c02, 0x8a052d02, + 0x8a052e02, 0x8a052f02, 0x8a053002, 0x8a053102, 0x8a053202, 0x8a053302, 0x8a053402, 0x8a053502, + 0x8a053602, 0x8a053702, 0x8a053802, 0x8a053902, 0x8a053a02, 0x8a053b02, 0x8a053c02, 0x8a053d02, + 0x8a053e02, 0x8a053f02, 0x8a054002, 0x8a054102, 0x8a054202, 0x8a054302, 0x8a054402, 0x8a054502, + 0x8a054602, 0x8a054702, 0x8a054802, 0x8a054902, 0x8a054a02, 0x8a054b02, 0x8a054c02, 0x8a054d02, + 0x8a054e02, 0x8a054f02, 0x8a055002, 0x8a055102, 0x8a055202, 0x8a055302, 0x8a055402, 0x8a055502, + 0x8a055602, 0x8a055702, 0x8a055802, 0x8a055902, 0x8a055a02, 0x8a055b02, 0x8a055c02, 0x8a055d02, + 0x8a055e02, 0x8a055f02, 0x8a056002, 0x8a056102, 0x8a056202, 0x8a056302, 0x8a056402, 0x8a056502, + 0x8a056602, 0x8a056702, 0x8a056802, 0x8a056902, 0x8a056a02, 0x8a056b02, 0x8a056c02, 0x8a056d02, + 0x8a056e02, 0x8a056f02, 0x8a057002, 0x8a057102, 0x8a057202, 0x8a057302, 0x8a057402, 0x8a057502, + 0x8a057602, 0x8a057702, 0x8a057802, 0x8a057902, 0x8a057a02, 0x8a057b02, 0x8a057c02, 0x8a057d02, + 0x8a057e02, 0x8a057f02, 0x8a058002, 0x8a058102, 0x8a058202, 0x8a058302, 0x8a058402, 0x8a058502, + 0x8a058602, 0x8a058702, 0x8a058802, 0x8a058902, 0x8a058a02, 0x8a058b02, 0x8a058c02, 0x8a058d02, + 0x8a058e02, 0x8a058f02, 0x8a059002, 0x8a059102, 0x8a059202, 0x8a059302, 0x8a059402, 0x8a059502, + 0x8a059602, 0x8a059702, 0x8a059802, 0x8a059902, 0x8a059a02, 0x8a059b02, 0x8a059c02, 0x8a059d02, + 0x8a059e02, 0x8a059f02, 0x8a05a002, 0x8a05a102, 0x8a05a202, 0x8a05a302, 0x8a05a402, 0x8a05a502, + 0x8a05a602, 0x8a05a702, 0x8a05a802, 0x8a05a902, 0x8a05aa02, 0x8a05ab02, 0x8a05ac02, 0x8a05ad02, + 0x8a05ae02, 0x8a05af02, 0x8a05b002, 0x8a05b102, 0x8a05b202, 0x8a05b302, 0x8a05b402, 0x8a05b502, + 0x8a05b602, 0x8a05b702, 0x8a05b802, 0x8a05b902, 0x8a05ba02, 0x8a05bb02, 0x8a05bc02, 0x8a05bd02, + 0x8a05be02, 0x8a05bf02, 0x8a05c002, 0x8a05c102, 0x8a05c202, 0x8a05c302, 0x8a05c402, 0x8a05c502, + 0x8a05c602, 0x8a05c702, 0x8a05c802, 0x8a05c902, 0x8a05ca02, 0x8a05cb02, 0x8a05cc02, 0x8a05cd02, + 0x8a05ce02, 0x8a05cf02, 0x8a05d002, 0x8a05d102, 0x8a05d202, 0x8a05d302, 0x8a05d402, 0x8a05d502, + 0x8a05d602, 0x8a05d702, 0x8a05d802, 0x8a05d902, 0x8a05da02, 0x8a05db02, 0x8a05dc02, 0x8a05dd02, + 0x8a05de02, 0x8a05df02, 0x8a05e002, 0x8a05e102, 0x8a05e202, 0x8a05e302, 0x8a05e402, 0x8a05e502, + 0x8a05e602, 0x8a05e702, 0x8a05e802, 0x8a05e902, 0x8a05ea02, 0x8a05eb02, 0x8a05ec02, 0x8a05ed02, + 0x8a05ee02, 0x8a05ef02, 0x8a05f002, 0x8a05f102, 0x8a05f202, 0x8a05f302, 0x8a05f402, 0x8a05f502, + 0x8a05f602, 0x8a05f702, 0x8a05f802, 0x8a05f902, 0x8a05fa02, 0x8a05fb02, 0x8a05fc02, 0x8a05fd02, + 0x8a05fe02, 0x8a05ff02, 0x8b050202, 0x8b050302, 0x8b050402, 0x8b050502, 0x8b050602, 0x8b050702, + 0x8b050802, 0x8b050902, 0x8b050a02, 0x8b050b02, 0x8b050c02, 0x8b050d02, 0x8b050e02, 0x8b050f02, + 0x8b051002, 0x8b051102, 0x8b051202, 0x8b051302, 0x8b051402, 0x8b051502, 0x8b051602, 0x8b051702, + 0x8b051802, 0x8b051902, 0x8b051a02, 0x8b051b02, 0x8b051c02, 0x8b051d02, 0x8b051e02, 0x8b051f02, + 0x8b052002, 0x8b052102, 0x8b052202, 0x8b052302, 0x8b052402, 0x8b052502, 0x8b052602, 0x8b052702, + 0x8b052802, 0x8b052902, 0x8b052a02, 0x8b052b02, 0x8b052c02, 0x8b052d02, 0x8b052e02, 0x8b052f02, + 0x8b053002, 0x8b053102, 0x8b053202, 0x8b053302, 0x8b053402, 0x8b053502, 0x8b053602, 0x8b053702, + 0x8b053802, 0x8b053902, 0x8b053a02, 0x8b053b02, 0x8b053c02, 0x8b053d02, 0x8b053e02, 0x8b053f02, + 0x8b054002, 0x8b054102, 0x8b054202, 0x8b054302, 0x8b054402, 0x8b054502, 0x8b054602, 0x8b054702, + 0x8b054802, 0x8b054902, 0x8b054a02, 0x8b054b02, 0x8b054c02, 0x8b054d02, 0x8b054e02, 0x8b054f02, + 0x8b055002, 0x8b055102, 0x8b055202, 0x8b055302, 0x8b055402, 0x8b055502, 0x8b055602, 0x8b055702, + 0x8b055802, 0x8b055902, 0x8b055a02, 0x8b055b02, 0x8b055c02, 0x8b055d02, 0x8b055e02, 0x8b055f02, + 0x8b056002, 0x8b056102, 0x8b056202, 0x8b056302, 0x8b056402, 0x8b056502, 0x8b056602, 0x8b056702, + 0x8b056802, 0x8b056902, 0x8b056a02, 0x8b056b02, 0x8b056c02, 0x8b056d02, 0x8b056e02, 0x8b056f02, + 0x8b057002, 0x8b057102, 0x8b057202, 0x8b057302, 0x8b057402, 0x8b057502, 0x8b057602, 0x8b057702, + 0x8b057802, 0x8b057902, 0x8b057a02, 0x8b057b02, 0x8b057c02, 0x8b057d02, 0x8b057e02, 0x8b057f02, + 0x8b058002, 0x8b058102, 0x8b058202, 0x8b058302, 0x8b058402, 0x8b058502, 0x8b058602, 0x8b058702, + 0x8b058802, 0x8b058902, 0x8b058a02, 0x8b058b02, 0x8b058c02, 0x8b058d02, 0x8b058e02, 0x8b058f02, + 0x8b059002, 0x8b059102, 0x8b059202, 0x8b059302, 0x8b059402, 0x8b059502, 0x8b059602, 0x8b059702, + 0x8b059802, 0x8b059902, 0x8b059a02, 0x8b059b02, 0x8b059c02, 0x8b059d02, 0x8b059e02, 0x8b059f02, + 0x8b05a002, 0x8b05a102, 0x8b05a202, 0x8b05a302, 0x8b05a402, 0x8b05a502, 0x8b05a602, 0x8b05a702, + 0x8b05a802, 0x8b05a902, 0x8b05aa02, 0x8b05ab02, 0x8b05ac02, 0x8b05ad02, 0x8b05ae02, 0x8b05af02, + 0x8b05b002, 0x8b05b102, 0x8b05b202, 0x8b05b302, 0x8b05b402, 0x8b05b502, 0x8b05b602, 0x8b05b702, + 0x8b05b802, 0x8b05b902, 0x8b05ba02, 0x8b05bb02, 0x8b05bc02, 0x8b05bd02, 0x8b05be02, 0x8b05bf02, + 0x8b05c002, 0x8b05c102, 0x8b05c202, 0x8b05c302, 0x8b05c402, 0x8b05c502, 0x8b05c602, 0x8b05c702, + 0x8b05c802, 0x8b05c902, 0x8b05ca02, 0x8b05cb02, 0x8b05cc02, 0x8b05cd02, 0x8b05ce02, 0x8b05cf02, + 0x8b05d002, 0x8b05d102, 0x8b05d202, 0x8b05d302, 0x8b05d402, 0x8b05d502, 0x8b05d602, 0x8b05d702, + 0x8b05d802, 0x8b05d902, 0x8b05da02, 0x8b05db02, 0x8b05dc02, 0x8b05dd02, 0x8b05de02, 0x8b05df02, + 0x8b05e002, 0x8b05e102, 0x8b05e202, 0x8b05e302, 0x8b05e402, 0x8b05e502, 0x8b05e602, 0x8b05e702, + 0x8b05e802, 0x8b05e902, 0x8b05ea02, 0x8b05eb02, 0x8b05ec02, 0x8b05ed02, 0x8b05ee02, 0x8b05ef02, + 0x8b05f002, 0x8b05f102, 0x8b05f202, 0x8b05f302, 0x8b05f402, 0x8b05f502, 0x8b05f602, 0x8b05f702, + 0x8b05f802, 0x8b05f902, 0x8b05fa02, 0x8b05fb02, 0x8b05fc02, 0x8b05fd02, 0x8b05fe02, 0x8b05ff02, + 0x8c050202, 0x8c050302, 0x8c050402, 0x8c050502, 0x8c050602, 0x8c050702, 0x8c050802, 0x8c050902, + 0x8c050a02, 0x8c050b02, 0x8c050c02, 0x8c050d02, 0x8c050e02, 0x8c050f02, 0x8c051002, 0x8c051102, + 0x8c051202, 0x8c051302, 0x8c051402, 0x8c051502, 0x8c051602, 0x8c051702, 0x8c051802, 0x8c051902, + 0x8c051a02, 0x8c051b02, 0x8c051c02, 0x8c051d02, 0x8c051e02, 0x8c051f02, 0x8c052002, 0x8c052102, + 0x8c052202, 0x8c052302, 0x8c052402, 0x8c052502, 0x8c052602, 0x8c052702, 0x8c052802, 0x8c052902, + 0x8c052a02, 0x8c052b02, 0x8c052c02, 0x8c052d02, 0x8c052e02, 0x8c052f02, 0x8c053002, 0x8c053102, + 0x8c053202, 0x8c053302, 0x8c053402, 0x8c053502, 0x8c053602, 0x8c053702, 0x8c053802, 0x8c053902, + 0x8c053a02, 0x8c053b02, 0x8c053c02, 0x8c053d02, 0x8c053e02, 0x8c053f02, 0x8c054002, 0x8c054102, + 0x8c054202, 0x8c054302, 0x8c054402, 0x8c054502, 0x8c054602, 0x8c054702, 0x8c054802, 0x8c054902, + 0x8c054a02, 0x8c054b02, 0x8c054c02, 0x8c054d02, 0x8c054e02, 0x8c054f02, 0x8c055002, 0x8c055102, + 0x8c055202, 0x8c055302, 0x8c055402, 0x8c055502, 0x8c055602, 0x8c055702, 0x8c055802, 0x8c055902, + 0x8c055a02, 0x8c055b02, 0x8c055c02, 0x8c055d02, 0x8c055e02, 0x8c055f02, 0x8c056002, 0x8c056102, + 0x8c056202, 0x8c056302, 0x8c056402, 0x8c056502, 0x8c056602, 0x8c056702, 0x8c056802, 0x8c056902, + 0x8c056a02, 0x8c056b02, 0x8c056c02, 0x8c056d02, 0x8c056e02, 0x8c056f02, 0x8c057002, 0x8c057102, + 0x8c057202, 0x8c057302, 0x8c057402, 0x8c057502, 0x8c057602, 0x8c057702, 0x8c057802, 0x8c057902, + 0x8c057a02, 0x8c057b02, 0x8c057c02, 0x8c057d02, 0x8c057e02, 0x8c057f02, 0x8c058002, 0x8c058102, + 0x8c058202, 0x8c058302, 0x8c058402, 0x8c058502, 0x8c058602, 0x8c058702, 0x8c058802, 0x8c058902, + 0x8c058a02, 0x8c058b02, 0x8c058c02, 0x8c058d02, 0x8c058e02, 0x8c058f02, 0x8c059002, 0x8c059102, + 0x8c059202, 0x8c059302, 0x8c059402, 0x8c059502, 0x8c059602, 0x8c059702, 0x8c059802, 0x8c059902, + 0x8c059a02, 0x8c059b02, 0x8c059c02, 0x8c059d02, 0x8c059e02, 0x8c059f02, 0x8c05a002, 0x8c05a102, + 0x8c05a202, 0x8c05a302, 0x8c05a402, 0x8c05a502, 0x8c05a602, 0x8c05a702, 0x8c05a802, 0x8c05a902, + 0x8c05aa02, 0x8c05ab02, 0x8c05ac02, 0x8c05ad02, 0x8c05ae02, 0x8c05af02, 0x8c05b002, 0x8c05b102, + 0x8c05b202, 0x8c05b302, 0x8c05b402, 0x8c05b502, 0x8c05b602, 0x8c05b702, 0x8c05b802, 0x8c05b902, + 0x8c05ba02, 0x8c05bb02, 0x8c05bc02, 0x8c05bd02, 0x8c05be02, 0x8c05bf02, 0x8c05c002, 0x8c05c102, + 0x8c05c202, 0x8c05c302, 0x8c05c402, 0x8c05c502, 0x8c05c602, 0x8c05c702, 0x8c05c802, 0x8c05c902, + 0x8c05ca02, 0x8c05cb02, 0x8c05cc02, 0x8c05cd02, 0x8c05ce02, 0x8c05cf02, 0x8c05d002, 0x8c05d102, + 0x8c05d202, 0x8c05d302, 0x8c05d402, 0x8c05d502, 0x8c05d602, 0x8c05d702, 0x8c05d802, 0x8c05d902, + 0x8c05da02, 0x8c05db02, 0x8c05dc02, 0x8c05dd02, 0x8c05de02, 0x8c05df02, 0x8c05e002, 0x8c05e102, + 0x8c05e202, 0x8c05e302, 0x8c05e402, 0x8c05e502, 0x8c05e602, 0x8c05e702, 0x8c05e802, 0x8c05e902, + 0x8c05ea02, 0x8c05eb02, 0x8c05ec02, 0x8c05ed02, 0x8c05ee02, 0x8c05ef02, 0x8c05f002, 0x8c05f102, + 0x8c05f202, 0x8c05f302, 0x8c05f402, 0x8c05f502, 0x8c05f602, 0x8c05f702, 0x8c05f802, 0x8c05f902, + 0x8c05fa02, 0x8c05fb02, 0x8c05fc02, 0x8c05fd02, 0x8c05fe02, 0x8c05ff02, 0x8d050202, 0x8d050302, + 0x8d050402, 0x8d050502, 0x8d050602, 0x8d050702, 0x8d050802, 0x8d050902, 0x8d050a02, 0x8d050b02, + 0x8d050c02, 0x8d050d02, 0x8d050e02, 0x8d050f02, 0x8d051002, 0x8d051102, 0x8d051202, 0x8d051302, + 0x8d051402, 0x8d051502, 0x8d051602, 0x8d051702, 0x8d051802, 0x8d051902, 0x8d051a02, 0x8d051b02, + 0x8d051c02, 0x8d051d02, 0x8d051e02, 0x8d051f02, 0x8d052002, 0x8d052102, 0x8d052202, 0x8d052302, + 0x8d052402, 0x8d052502, 0x8d052602, 0x8d052702, 0x8d052802, 0x8d052902, 0x8d052a02, 0x8d052b02, + 0x8d052c02, 0x8d052d02, 0x8d052e02, 0x8d052f02, 0x8d053002, 0x8d053102, 0x8d053202, 0x8d053302, + 0x8d053402, 0x8d053502, 0x8d053602, 0x8d053702, 0x8d053802, 0x8d053902, 0x8d053a02, 0x8d053b02, + 0x8d053c02, 0x8d053d02, 0x8d053e02, 0x8d053f02, 0x8d054002, 0x8d054102, 0x8d054202, 0x8d054302, + 0x8d054402, 0x8d054502, 0x8d054602, 0x8d054702, 0x8d054802, 0x8d054902, 0x8d054a02, 0x8d054b02, + 0x8d054c02, 0x8d054d02, 0x8d054e02, 0x8d054f02, 0x8d055002, 0x8d055102, 0x8d055202, 0x8d055302, + 0x8d055402, 0x8d055502, 0x8d055602, 0x8d055702, 0x8d055802, 0x8d055902, 0x8d055a02, 0x8d055b02, + 0x8d055c02, 0x8d055d02, 0x8d055e02, 0x8d055f02, 0x8d056002, 0x8d056102, 0x8d056202, 0x8d056302, + 0x8d056402, 0x8d056502, 0x8d056602, 0x8d056702, 0x8d056802, 0x8d056902, 0x8d056a02, 0x8d056b02, + 0x8d056c02, 0x8d056d02, 0x8d056e02, 0x8d056f02, 0x8d057002, 0x8d057102, 0x8d057202, 0x8d057302, + 0x8d057402, 0x8d057502, 0x8d057602, 0x8d057702, 0x8d057802, 0x8d057902, 0x8d057a02, 0x8d057b02, + 0x8d057c02, 0x8d057d02, 0x8d057e02, 0x8d057f02, 0x8d058002, 0x8d058102, 0x8d058202, 0x8d058302, + 0x8d058402, 0x8d058502, 0x8d058602, 0x8d058702, 0x8d058802, 0x8d058902, 0x8d058a02, 0x8d058b02, + 0x8d058c02, 0x8d058d02, 0x8d058e02, 0x8d058f02, 0x8d059002, 0x8d059102, 0x8d059202, 0x8d059302, + 0x8d059402, 0x8d059502, 0x8d059602, 0x8d059702, 0x8d059802, 0x8d059902, 0x8d059a02, 0x8d059b02, + 0x8d059c02, 0x8d059d02, 0x8d059e02, 0x8d059f02, 0x8d05a002, 0x8d05a102, 0x8d05a202, 0x8d05a302, + 0x8d05a402, 0x8d05a502, 0x8d05a602, 0x8d05a702, 0x8d05a802, 0x8d05a902, 0x8d05aa02, 0x8d05ab02, + 0x8d05ac02, 0x8d05ad02, 0x8d05ae02, 0x8d05af02, 0x8d05b002, 0x8d05b102, 0x8d05b202, 0x8d05b302, + 0x8d05b402, 0x8d05b502, 0x8d05b602, 0x8d05b702, 0x8d05b802, 0x8d05b902, 0x8d05ba02, 0x8d05bb02, + 0x8d05bc02, 0x8d05bd02, 0x8d05be02, 0x8d05bf02, 0x8d05c002, 0x8d05c102, 0x8d05c202, 0x8d05c302, + 0x8d05c402, 0x8d05c502, 0x8d05c602, 0x8d05c702, 0x8d05c802, 0x8d05c902, 0x8d05ca02, 0x8d05cb02, + 0x8d05cc02, 0x8d05cd02, 0x8d05ce02, 0x8d05cf02, 0x8d05d002, 0x8d05d102, 0x8d05d202, 0x8d05d302, + 0x8d05d402, 0x8d05d502, 0x8d05d602, 0x8d05d702, 0x8d05d802, 0x8d05d902, 0x8d05da02, 0x8d05db02, + 0x8d05dc02, 0x8d05dd02, 0x8d05de02, 0x8d05df02, 0x8d05e002, 0x8d05e102, 0x8d05e202, 0x8d05e302, + 0x8d05e402, 0x8d05e502, 0x8d05e602, 0x8d05e702, 0x8d05e802, 0x8d05e902, 0x8d05ea02, 0x8d05eb02, + 0x8d05ec02, 0x8d05ed02, 0x8d05ee02, 0x8d05ef02, 0x8d05f002, 0x8d05f102, 0x8d05f202, 0x8d05f302, + 0x8d05f402, 0x8d05f502, 0x8d05f602, 0x8d05f702, 0x8d05f802, 0x8d05f902, 0x8d05fa02, 0x8d05fb02, + 0x8d05fc02, 0x8d05fd02, 0x8d05fe02, 0x8d05ff02, 0x8e050202, 0x8e050302, 0x8e050402, 0x8e050502, + 0x8e050602, 0x8e050702, 0x8e050802, 0x8e050902, 0x8e050a02, 0x8e050b02, 0x8e050c02, 0x8e050d02, + 0x8e050e02, 0x8e050f02, 0x8e051002, 0x8e051102, 0x8e051202, 0x8e051302, 0x8e051402, 0x8e051502, + 0x8e051602, 0x8e051702, 0x8e051802, 0x8e051902, 0x8e051a02, 0x8e051b02, 0x8e051c02, 0x8e051d02, + 0x8e051e02, 0x8e051f02, 0x8e052002, 0x8e052102, 0x8e052202, 0x8e052302, 0x8e052402, 0x8e052502, + 0x8e052602, 0x8e052702, 0x8e052802, 0x8e052902, 0x8e052a02, 0x8e052b02, 0x8e052c02, 0x8e052d02, + 0x8e052e02, 0x8e052f02, 0x8e053002, 0x8e053102, 0x8e053202, 0x8e053302, 0x8e053402, 0x8e053502, + 0x8e053602, 0x8e053702, 0x8e053802, 0x8e053902, 0x8e053a02, 0x8e053b02, 0x8e053c02, 0x8e053d02, + 0x8e053e02, 0x8e053f02, 0x8e054002, 0x8e054102, 0x8e054202, 0x8e054302, 0x8e054402, 0x8e054502, + 0x8e054602, 0x8e054702, 0x8e054802, 0x8e054902, 0x8e054a02, 0x8e054b02, 0x8e054c02, 0x8e054d02, + 0x8e054e02, 0x8e054f02, 0x8e055002, 0x8e055102, 0x8e055202, 0x8e055302, 0x8e055402, 0x8e055502, + 0x8e055602, 0x8e055702, 0x8e055802, 0x8e055902, 0x8e055a02, 0x8e055b02, 0x8e055c02, 0x8e055d02, + 0x8e055e02, 0x8e055f02, 0x8e056002, 0x8e056102, 0x8e056202, 0x8e056302, 0x8e056402, 0x8e056502, + 0x8e056602, 0x8e056702, 0x8e056802, 0x8e056902, 0x8e056a02, 0x8e056b02, 0x8e056c02, 0x8e056d02, + 0x8e056e02, 0x8e056f02, 0x8e057002, 0x8e057102, 0x8e057202, 0x8e057302, 0x8e057402, 0x8e057502, + 0x8e057602, 0x8e057702, 0x8e057802, 0x8e057902, 0x8e057a02, 0x8e057b02, 0x8e057c02, 0x8e057d02, + 0x8e057e02, 0x8e057f02, 0x8e058002, 0x8e058102, 0x8e058202, 0x8e058302, 0x8e058402, 0x8e058502, + 0x8e058602, 0x8e058702, 0x8e058802, 0x8e058902, 0x8e058a02, 0x8e058b02, 0x8e058c02, 0x8e058d02, + 0x8e058e02, 0x8e058f02, 0x8e059002, 0x8e059102, 0x8e059202, 0x8e059302, 0x8e059402, 0x8e059502, + 0x8e059602, 0x8e059702, 0x8e059802, 0x8e059902, 0x8e059a02, 0x8e059b02, 0x8e059c02, 0x8e059d02, + 0x8e059e02, 0x8e059f02, 0x8e05a002, 0x8e05a102, 0x8e05a202, 0x8e05a302, 0x8e05a402, 0x8e05a502, + 0x8e05a602, 0x8e05a702, 0x8e05a802, 0x8e05a902, 0x8e05aa02, 0x8e05ab02, 0x8e05ac02, 0x8e05ad02, + 0x8e05ae02, 0x8e05af02, 0x8e05b002, 0x8e05b102, 0x8e05b202, 0x8e05b302, 0x8e05b402, 0x8e05b502, + 0x8e05b602, 0x8e05b702, 0x8e05b802, 0x8e05b902, 0x8e05ba02, 0x8e05bb02, 0x8e05bc02, 0x8e05bd02, + 0x8e05be02, 0x8e05bf02, 0x8e05c002, 0x8e05c102, 0x8e05c202, 0x8e05c302, 0x8e05c402, 0x8e05c502, + 0x8e05c602, 0x8e05c702, 0x8e05c802, 0x8e05c902, 0x8e05ca02, 0x8e05cb02, 0x8e05cc02, 0x8e05cd02, + 0x8e05ce02, 0x8e05cf02, 0x8e05d002, 0x8e05d102, 0x8e05d202, 0x8e05d302, 0x8e05d402, 0x8e05d502, + 0x8e05d602, 0x8e05d702, 0x8e05d802, 0x8e05d902, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x02560202, 0x03560202, 0x04560202, 0x05560202, 0x06560202, 0x07560202, 0x08560202, 0x09560202, + 0x0a560202, 0x0b560202, 0x0c560202, 0x0d560202, 0x0e560202, 0x0f560202, 0x10560202, 0x11560202, + 0x12560202, 0x13560202, 0x14560202, 0x15560202, 0x16560202, 0x00030707, 0x17560202, 0x18560202, + 0x19560202, 0x1a560202, 0x1b560202, 0x1c560202, 0x1d560202, 0x1e560202, 0x1f560202, 0x20560202, + 0x21560202, 0x22560202, 0x23560202, 0x24560202, 0x25560202, 0x26560202, 0x27560202, 0x28560202, + 0x29560202, 0x2a560202, 0x2b560202, 0x2c560202, 0x2d560202, 0x2e560202, 0x2f560202, 0x30560202, + 0x31560202, 0x32560202, 0x33560202, 0x34560202, 0x35560202, 0x36560202, 0x37560202, 0x38560202, + 0x39560202, 0x3a560202, 0x3b560202, 0x3c560202, 0x3d560202, 0x3e560202, 0x3f560202, 0x40560202, + 0x41560202, 0x42560202, 0x43560202, 0x44560202, 0x45560202, 0x46560202, 0x47560202, 0x48560202, + 0x49560202, 0x4a560202, 0x4b560202, 0x4c560202, 0x4d560202, 0x4e560202, 0x4f560202, 0x50560202, + 0x51560202, 0x52560202, 0x53560202, 0x54560202, 0x55560202, 0x56560202, 0x57560202, 0x58560202, + 0x59560202, 0x5a560202, 0x5b560202, 0x5c560202, 0x5d560202, 0x5e560202, 0x5f560202, 0x60560202, + 0x61560202, 0x62560202, 0x63560202, 0x64560202, 0x65560202, 0x66560202, 0x67560202, 0x68560202, + 0x69560202, 0x6a560202, 0x6b560202, 0x6c560202, 0x6d560202, 0x6e560202, 0x6f560202, 0x70560202, + 0x71560202, 0x72560202, 0x73560202, 0x74560202, 0x75560202, 0x76560202, 0x77560202, 0x78560202, + 0x79560202, 0x7a560202, 0x7b560202, 0x7c560202, 0x7d560202, 0x7e560202, 0x7f560202, 0x80560202, + 0x81560202, 0x82560202, 0x83560202, 0x84560202, 0x85560202, 0x86560202, 0x87560202, 0x88560202, + 0x89560202, 0x8a560202, 0x8b560202, 0x8c560202, 0x8d560202, 0x8e560202, 0x8f560202, 0x90560202, + 0x91560202, 0x92560202, 0x93560202, 0x94560202, 0x95560202, 0x96560202, 0x97560202, 0x98560202, + 0x99560202, 0x9a560202, 0x9b560202, 0x9c560202, 0x9d560202, 0x9e560202, 0x9f560202, 0xa0560202, + 0xa1560202, 0xa2560202, 0xa3560202, 0xa4560202, 0xa5560202, 0xa6560202, 0xa7560202, 0xa8560202, + 0xa9560202, 0xaa560202, 0xab560202, 0xac560202, 0xad560202, 0xae560202, 0xaf560202, 0xb0560202, + 0xb1560202, 0xb2560202, 0xb3560202, 0xb4560202, 0xb5560202, 0xb6560202, 0xb7560202, 0xb8560202, + 0xb9560202, 0xb9560202, 0xba560202, 0xbb560202, 0xbc560202, 0xbd560202, 0xbe560202, 0xbf560202, + 0xc0560202, 0xc1560202, 0xc2560202, 0xc3560202, 0xc4560202, 0xc5560202, 0xc6560202, 0xc7560202, + 0xc8560202, 0xc9560202, 0xca560202, 0xcb560202, 0xcc560202, 0xcd560202, 0xce560202, 0xcf560202, + 0xd0560202, 0xd1560202, 0xd2560202, 0xd3560202, 0xd4560202, 0xd5560202, 0xd6560202, 0xd7560202, + 0xd8560202, 0xd9560202, 0xda560202, 0xdb560202, 0xdc560202, 0xdd560202, 0xde560202, 0xdf560202, + 0xe0560202, 0xe1560202, 0xe2560202, 0xe3560202, 0xe4560202, 0xe5560202, 0xe6560202, 0xe7560202, + 0xe8560202, 0xe9560202, 0xea560202, 0xeb560202, 0xec560202, 0xed560202, 0xee560202, 0xef560202, + 0xf0560202, 0xf1560202, 0xf2560202, 0xf3560202, 0xf4560202, 0xf5560202, 0xf6560202, 0xf7560202, + 0xf8560202, 0xf9560202, 0xfa560202, 0xfb560202, 0xfc560202, 0xfd560202, 0xfe560202, 0xff560202, + 0x02570202, 0x03570202, 0x04570202, 0x05570202, 0x06570202, 0x07570202, 0x08570202, 0x09570202, + 0x0a570202, 0x0b570202, 0x0c570202, 0x0d570202, 0x0e570202, 0x0f570202, 0x10570202, 0x11570202, + 0x12570202, 0x13570202, 0x14570202, 0x15570202, 0x16570202, 0x17570202, 0x18570202, 0x19570202, + 0x1a570202, 0x1b570202, 0x1c570202, 0x1d570202, 0x1e570202, 0x1f570202, 0x20570202, 0x21570202, + 0x22570202, 0x23570202, 0x24570202, 0x25570202, 0x26570202, 0x27570202, 0x28570202, 0x29570202, + 0x2a570202, 0x2b570202, 0x2c570202, 0x2d570202, 0x2e570202, 0x2f570202, 0x30570202, 0x31570202, + 0x32570202, 0x33570202, 0x34570202, 0x35570202, 0x36570202, 0x37570202, 0x38570202, 0x39570202, + 0x3a570202, 0x3b570202, 0x3c570202, 0x3d570202, 0x3e570202, 0x3f570202, 0x40570202, 0x41570202, + 0x42570202, 0x43570202, 0x44570202, 0x45570202, 0x46570202, 0x47570202, 0x48570202, 0x49570202, + 0x4a570202, 0x4b570202, 0x4c570202, 0x4d570202, 0x4e570202, 0x4f570202, 0x50570202, 0x51570202, + 0x52570202, 0x53570202, 0x54570202, 0x55570202, 0x56570202, 0x57570202, 0x58570202, 0x59570202, + 0x5a570202, 0x5b570202, 0x5c570202, 0x5d570202, 0x5e570202, 0x5f570202, 0x60570202, 0x61570202, + 0x62570202, 0x63570202, 0x64570202, 0x65570202, 0x66570202, 0x67570202, 0x68570202, 0x69570202, + 0x6a570202, 0x6b570202, 0x6c570202, 0x6d570202, 0x6e570202, 0x6f570202, 0x70570202, 0x71570202, + 0x72570202, 0x73570202, 0x74570202, 0x75570202, 0x76570202, 0x77570202, 0x78570202, 0x79570202, + 0x7a570202, 0x7b570202, 0x7c570202, 0x7d570202, 0x7e570202, 0x7f570202, 0x80570202, 0x81570202, + 0x82570202, 0x83570202, 0x84570202, 0x85570202, 0x86570202, 0x87570202, 0x88570202, 0x89570202, + 0x8a570202, 0x8b570202, 0x8c570202, 0x8d570202, 0x8e570202, 0x8f570202, 0x90570202, 0x91570202, + 0x92570202, 0x93570202, 0x94570202, 0x95570202, 0x96570202, 0x97570202, 0x98570202, 0x99570202, + 0x9a570202, 0x9b570202, 0x9c570202, 0x9d570202, 0x9e570202, 0x9f570202, 0xa0570202, 0xa1570202, + 0xa2570202, 0xa3570202, 0xa4570202, 0xa5570202, 0xa6570202, 0xa7570202, 0xa8570202, 0xa9570202, + 0xaa570202, 0xab570202, 0xac570202, 0xad570202, 0xae570202, 0xaf570202, 0xb0570202, 0xb1570202, + 0xb2570202, 0xb3570202, 0xb4570202, 0xb5570202, 0xb6570202, 0xb7570202, 0xb8570202, 0xb9570202, + 0xbb570202, 0xbc570202, 0xbd570202, 0xbe570202, 0xbf570202, 0xc0570202, 0xc1570202, 0xc2570202, + 0xc3570202, 0xc4570202, 0xc5570202, 0xc6570202, 0xc7570202, 0xc8570202, 0xc9570202, 0xca570202, + 0xcb570202, 0xcc570202, 0xcd570202, 0xce570202, 0xcf570202, 0xd0570202, 0xd1570202, 0xd2570202, + 0xd3570202, 0xd4570202, 0xd5570202, 0xd6570202, 0xd7570202, 0xd8570202, 0xd9570202, 0xda570202, + 0xdb570202, 0xdc570202, 0xdd570202, 0xde570202, 0xdf570202, 0xe0570202, 0xe1570202, 0xe2570202, + 0xe3570202, 0xe4570202, 0xe5570202, 0xe6570202, 0xe7570202, 0xe8570202, 0xe9570202, 0xea570202, + 0xeb570202, 0xec570202, 0xed570202, 0xee570202, 0xef570202, 0xf0570202, 0xf1570202, 0xf2570202, + 0xf3570202, 0xf4570202, 0xf5570202, 0xf6570202, 0xf7570202, 0xf8570202, 0xf9570202, 0xfa570202, + 0xfb570202, 0xfc570202, 0xfd570202, 0xfe570202, 0xff570202, 0x02580202, 0x03580202, 0x04580202, + 0x05580202, 0x06580202, 0x07580202, 0x08580202, 0x09580202, 0x0a580202, 0x0b580202, 0x0c580202, + 0x0d580202, 0x0e580202, 0x0f580202, 0x10580202, 0x11580202, 0x12580202, 0x13580202, 0x14580202, + 0x15580202, 0x16580202, 0x17580202, 0x18580202, 0x19580202, 0x1a580202, 0x1b580202, 0x1c580202, + 0x1d580202, 0x1e580202, 0x1f580202, 0x20580202, 0x21580202, 0x22580202, 0x23580202, 0x24580202, + 0x25580202, 0x26580202, 0x27580202, 0x28580202, 0x29580202, 0x2a580202, 0x2b580202, 0x2c580202, + 0x2d580202, 0x2e580202, 0x2f580202, 0x30580202, 0x31580202, 0x32580202, 0x33580202, 0x34580202, + 0x35580202, 0x36580202, 0x37580202, 0x38580202, 0x39580202, 0x3a580202, 0x3b580202, 0x3c580202, + 0x3d580202, 0x3e580202, 0x3f580202, 0x40580202, 0x41580202, 0x42580202, 0x43580202, 0x44580202, + 0x45580202, 0x46580202, 0x47580202, 0x48580202, 0x49580202, 0x4a580202, 0x4b580202, 0x4c580202, + 0x4d580202, 0x4e580202, 0x4f580202, 0x50580202, 0x51580202, 0x52580202, 0x53580202, 0x54580202, + 0x55580202, 0x56580202, 0x57580202, 0x58580202, 0x59580202, 0x5a580202, 0x5b580202, 0x5c580202, + 0x5d580202, 0x5e580202, 0x5f580202, 0x60580202, 0x61580202, 0x62580202, 0x63580202, 0x64580202, + 0x65580202, 0x66580202, 0x67580202, 0x68580202, 0x69580202, 0x6a580202, 0x6b580202, 0x6c580202, + 0x6d580202, 0x6e580202, 0x6f580202, 0x70580202, 0x71580202, 0x72580202, 0x73580202, 0x74580202, + 0x75580202, 0x76580202, 0x77580202, 0x78580202, 0x79580202, 0x7a580202, 0x7b580202, 0x7c580202, + 0x7d580202, 0x7e580202, 0x7f580202, 0x80580202, 0x81580202, 0x82580202, 0x83580202, 0x84580202, + 0x85580202, 0x86580202, 0x87580202, 0x88580202, 0x89580202, 0x8a580202, 0x8b580202, 0x8c580202, + 0x8d580202, 0x8e580202, 0x8f580202, 0x90580202, 0x91580202, 0x92580202, 0x93580202, 0x94580202, + 0x95580202, 0x96580202, 0x97580202, 0x98580202, 0x99580202, 0x9a580202, 0x9b580202, 0x9c580202, + 0x9d580202, 0x9e580202, 0x9f580202, 0xa0580202, 0xa1580202, 0xa2580202, 0xa3580202, 0xa4580202, + 0xa5580202, 0xa6580202, 0xa7580202, 0xa8580202, 0xa9580202, 0xaa580202, 0xab580202, 0xac580202, + 0xad580202, 0xae580202, 0xaf580202, 0xb0580202, 0xb1580202, 0xb2580202, 0xb3580202, 0xb4580202, + 0xb5580202, 0xb6580202, 0xb7580202, 0xb8580202, 0xb9580202, 0xba580202, 0xbb580202, 0xbc580202, + 0xbd580202, 0xbe580202, 0xbf580202, 0xc0580202, 0xc1580202, 0xc2580202, 0xc3580202, 0xc4580202, + 0xc5580202, 0xc6580202, 0xc7580202, 0xc8580202, 0xc9580202, 0xca580202, 0xcb580202, 0xcc580202, + 0xcd580202, 0xce580202, 0xcf580202, 0xd0580202, 0xd1580202, 0xd2580202, 0xd3580202, 0xd4580202, + 0xd5580202, 0xd6580202, 0xd7580202, 0xd8580202, 0xd9580202, 0xda580202, 0xdb580202, 0xdc580202, + 0xdd580202, 0xde580202, 0xdf580202, 0xe0580202, 0xe1580202, 0xe2580202, 0xe3580202, 0xe4580202, + 0xe5580202, 0xe6580202, 0xe7580202, 0xe8580202, 0xe9580202, 0xea580202, 0xeb580202, 0xec580202, + 0xed580202, 0xee580202, 0xef580202, 0xf0580202, 0xf1580202, 0xf2580202, 0xf3580202, 0xf4580202, + 0xf5580202, 0xf6580202, 0xf7580202, 0xf8580202, 0xf9580202, 0xfa580202, 0xfb580202, 0xfc580202, + 0xfd580202, 0xfe580202, 0xff580202, 0x02590202, 0x03590202, 0x04590202, 0x05590202, 0x06590202, + 0x07590202, 0x08590202, 0x09590202, 0x0a590202, 0x0b590202, 0x0c590202, 0x0d590202, 0x0e590202, + 0x0f590202, 0x10590202, 0x11590202, 0x12590202, 0x13590202, 0x14590202, 0x15590202, 0x16590202, + 0x17590202, 0x18590202, 0x19590202, 0x1a590202, 0x1b590202, 0x1c590202, 0x1d590202, 0x1e590202, + 0x1f590202, 0x20590202, 0x21590202, 0x22590202, 0x23590202, 0x24590202, 0x25590202, 0x26590202, + 0x27590202, 0x28590202, 0x29590202, 0x2a590202, 0x2b590202, 0x2c590202, 0x2d590202, 0x2e590202, + 0x2f590202, 0x30590202, 0x31590202, 0x32590202, 0x33590202, 0x34590202, 0x35590202, 0x36590202, + 0x37590202, 0x38590202, 0x39590202, 0x3a590202, 0x3b590202, 0x3c590202, 0x3d590202, 0x3e590202, + 0x3f590202, 0x40590202, 0x41590202, 0x42590202, 0x43590202, 0x44590202, 0x45590202, 0x46590202, + 0x47590202, 0x48590202, 0x49590202, 0x4a590202, 0x4b590202, 0x4c590202, 0x4d590202, 0x4e590202, + 0x4f590202, 0x50590202, 0x51590202, 0x52590202, 0x53590202, 0x54590202, 0x55590202, 0x56590202, + 0x57590202, 0x58590202, 0x59590202, 0x5a590202, 0x5b590202, 0x5c590202, 0x5d590202, 0x5e590202, + 0x5f590202, 0x60590202, 0x61590202, 0x62590202, 0x63590202, 0x64590202, 0x65590202, 0x66590202, + 0x67590202, 0x68590202, 0x69590202, 0x6a590202, 0x6b590202, 0x6c590202, 0x6d590202, 0x6e590202, + 0x6f590202, 0x70590202, 0x71590202, 0x72590202, 0x73590202, 0x74590202, 0x75590202, 0x76590202, + 0x77590202, 0x78590202, 0x79590202, 0x7a590202, 0x7b590202, 0x7c590202, 0x7d590202, 0x7e590202, + 0x7f590202, 0x80590202, 0x81590202, 0x82590202, 0x83590202, 0x84590202, 0x85590202, 0x86590202, + 0x87590202, 0x88590202, 0x89590202, 0x8a590202, 0x8b590202, 0x8c590202, 0x8d590202, 0x8e590202, + 0x8f590202, 0x90590202, 0x91590202, 0x92590202, 0x93590202, 0x94590202, 0x95590202, 0x96590202, + 0x97590202, 0x98590202, 0x99590202, 0x9a590202, 0x9b590202, 0x9c590202, 0x9d590202, 0x9e590202, + 0x9f590202, 0xa0590202, 0xa1590202, 0xa2590202, 0xa3590202, 0xa4590202, 0xa5590202, 0xa6590202, + 0xa7590202, 0xa8590202, 0xa9590202, 0xaa590202, 0xab590202, 0xac590202, 0xad590202, 0xae590202, + 0xaf590202, 0xb0590202, 0xb1590202, 0xb2590202, 0xb3590202, 0xb4590202, 0xb5590202, 0xb6590202, + 0xb7590202, 0xb8590202, 0xb9590202, 0xba590202, 0xbb590202, 0xbc590202, 0xbd590202, 0xbe590202, + 0xbf590202, 0xc0590202, 0xc1590202, 0xc2590202, 0xc3590202, 0xc4590202, 0xc5590202, 0xc6590202, + 0xc7590202, 0xc8590202, 0xc9590202, 0xca590202, 0xcb590202, 0xcc590202, 0xcd590202, 0xce590202, + 0xcf590202, 0xd0590202, 0xd1590202, 0xd2590202, 0xd3590202, 0xd4590202, 0xd5590202, 0xd6590202, + 0xd7590202, 0xd8590202, 0xd9590202, 0xda590202, 0xdb590202, 0xdc590202, 0xdd590202, 0xde590202, + 0xdf590202, 0xe0590202, 0xe1590202, 0xe2590202, 0xe3590202, 0xe4590202, 0xe5590202, 0xe6590202, + 0xe7590202, 0xe8590202, 0xe9590202, 0xea590202, 0xeb590202, 0xec590202, 0xed590202, 0xee590202, + 0xef590202, 0xf0590202, 0xf1590202, 0xf2590202, 0xf3590202, 0xf4590202, 0xf5590202, 0xf6590202, + 0xf7590202, 0xf8590202, 0xf9590202, 0xfa590202, 0xfb590202, 0xfc590202, 0xfd590202, 0xfe590202, + 0xff590202, 0x025a0202, 0x035a0202, 0x045a0202, 0x055a0202, 0x065a0202, 0x075a0202, 0x085a0202, + 0x095a0202, 0x0a5a0202, 0x0b5a0202, 0x0c5a0202, 0x0d5a0202, 0x0e5a0202, 0x0f5a0202, 0x105a0202, + 0x115a0202, 0x125a0202, 0x135a0202, 0x145a0202, 0x155a0202, 0x165a0202, 0x175a0202, 0x185a0202, + 0x195a0202, 0x1a5a0202, 0x1b5a0202, 0x1c5a0202, 0x1d5a0202, 0x1e5a0202, 0x1f5a0202, 0x205a0202, + 0x215a0202, 0x225a0202, 0x235a0202, 0x245a0202, 0x255a0202, 0x265a0202, 0x275a0202, 0x285a0202, + 0x295a0202, 0x2a5a0202, 0x2b5a0202, 0x2c5a0202, 0x2d5a0202, 0x2e5a0202, 0x2f5a0202, 0x305a0202, + 0x315a0202, 0x325a0202, 0x335a0202, 0x345a0202, 0x355a0202, 0x365a0202, 0x375a0202, 0x385a0202, + 0x395a0202, 0x3a5a0202, 0x3b5a0202, 0x3c5a0202, 0x3d5a0202, 0x3e5a0202, 0x3f5a0202, 0x405a0202, + 0x415a0202, 0x425a0202, 0x435a0202, 0x445a0202, 0x455a0202, 0x465a0202, 0x475a0202, 0x485a0202, + 0x495a0202, 0x4a5a0202, 0x4b5a0202, 0x4c5a0202, 0x4d5a0202, 0x4e5a0202, 0x4f5a0202, 0x505a0202, + 0x515a0202, 0x525a0202, 0x535a0202, 0x545a0202, 0x555a0202, 0x565a0202, 0x575a0202, 0x585a0202, + 0x595a0202, 0x5a5a0202, 0x5b5a0202, 0x5c5a0202, 0x5d5a0202, 0x5e5a0202, 0x5f5a0202, 0x605a0202, + 0x615a0202, 0x625a0202, 0x635a0202, 0x645a0202, 0x655a0202, 0x665a0202, 0x675a0202, 0x685a0202, + 0x695a0202, 0x6a5a0202, 0x6b5a0202, 0x6c5a0202, 0x6d5a0202, 0x6e5a0202, 0x6f5a0202, 0x705a0202, + 0x715a0202, 0x725a0202, 0x735a0202, 0x745a0202, 0x755a0202, 0x765a0202, 0x775a0202, 0x785a0202, + 0x795a0202, 0x7a5a0202, 0x7b5a0202, 0x7c5a0202, 0x7d5a0202, 0x7e5a0202, 0x7f5a0202, 0x805a0202, + 0x815a0202, 0x825a0202, 0x835a0202, 0x845a0202, 0x855a0202, 0x865a0202, 0x875a0202, 0x885a0202, + 0x895a0202, 0x8a5a0202, 0x8b5a0202, 0x8c5a0202, 0x8d5a0202, 0x8d5a0202, 0x8f5a0202, 0x905a0202, + 0x915a0202, 0x925a0202, 0x935a0202, 0x945a0202, 0x955a0202, 0x00000000, 0x00000000, 0x00000000, + 0xc85a0202, 0xc95a0202, 0xca5a0202, 0xcb5a0202, 0xcc5a0202, 0xcd5a0202, 0xce5a0202, 0xcf5a0202, + 0xd05a0202, 0xd15a0202, 0xd25a0202, 0xd35a0202, 0xd45a0202, 0xd55a0202, 0xd65a0202, 0xd75a0202, + 0xd85a0202, 0xd95a0202, 0xda5a0202, 0xdb5a0202, 0xdc5a0202, 0xdd5a0202, 0xdf5a0202, 0xe05a0202, + 0xe15a0202, 0xe25a0202, 0xe35a0202, 0xe45a0202, 0xe55a0202, 0xe65a0202, 0xe75a0202, 0xe85a0202, + 0xe95a0202, 0xea5a0202, 0xeb5a0202, 0xec5a0202, 0xed5a0202, 0xee5a0202, 0xef5a0202, 0xf05a0202, + 0xf15a0202, 0xf25a0202, 0xf35a0202, 0xf45a0202, 0xf55a0202, 0xf65a0202, 0xf75a0202, 0xf85a0202, + 0xf95a0202, 0xfa5a0202, 0xfb5a0202, 0xfc5a0202, 0xfd5a0202, 0xfe5a0202, 0xff5a0202, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x08670202, 0x09670202, 0x0a670202, 0x0b670202, 0x0c670202, 0x0d670202, 0x0e670202, 0x0f670202, + 0x10670202, 0x11670202, 0x12670202, 0x13670202, 0x14670202, 0x15670202, 0x16670202, 0x17670202, + 0x18670202, 0x19670202, 0x1a670202, 0x1b670202, 0x1c670202, 0x1d670202, 0x1e670202, 0x1f670202, + 0x20670202, 0x21670202, 0x24670202, 0x22670202, 0x25670202, 0x23670202, 0x26670202, 0x27670202, + 0x28670202, 0x29670202, 0x2a670202, 0x2b670202, 0x2c670202, 0x2d670202, 0x2e670202, 0x2f670202, + 0x02670202, 0x03670202, 0x04670202, 0x05670202, 0x07670202, 0x06670202, 0xdc070202, 0xdd070202, + 0x025e0202, 0x035e0202, 0x045e0202, 0x055e0202, 0x065e0202, 0x075e0202, 0x085e0202, 0x095e0202, + 0x0a5e0202, 0x0b5e0202, 0x0c5e0202, 0x0d5e0202, 0x0e5e0202, 0x105e0202, 0x115e0202, 0x125e0202, + 0x135e0202, 0x145e0202, 0x155e0202, 0x165e0202, 0x175e0202, 0x185e0202, 0x195e0202, 0x1a5e0202, + 0x1b5e0202, 0x1c5e0202, 0x1d5e0202, 0x1e5e0202, 0x1f5e0202, 0x205e0202, 0x215e0202, 0x235e0202, + 0x245e0202, 0x255e0202, 0x265e0202, 0x275e0202, 0x285e0202, 0x295e0202, 0x2a5e0202, 0x2b5e0202, + 0x2c5e0202, 0x2d5e0202, 0x2e5e0202, 0x2f5e0202, 0x305e0202, 0x315e0202, 0x325e0202, 0x335e0202, + 0x345e0202, 0x355e0202, 0x365e0202, 0x375e0202, 0x395e0202, 0x3a5e0202, 0x3b5e0202, 0x3c5e0202, + 0x3d5e0202, 0x3e5e0202, 0x3f5e0202, 0x405e0202, 0x415e0202, 0x425e0202, 0x435e0202, 0x445e0202, + 0x455e0202, 0x465e0202, 0x475e0202, 0x485e0202, 0x495e0202, 0x4a5e0202, 0x4b5e0202, 0x4c5e0202, + 0x4e5e0202, 0x4f5e0202, 0x505e0202, 0x515e0202, 0x525e0202, 0x535e0202, 0x545e0202, 0x555e0202, + 0x565e0202, 0x575e0202, 0x585e0202, 0x5a5e0202, 0x5b5e0202, 0x5c5e0202, 0x5d5e0202, 0x5e5e0202, + 0x5f5e0202, 0x615e0202, 0x625e0202, 0x645e0202, 0x655e0202, 0x665e0202, 0x675e0202, 0x685e0202, + 0x695e0202, 0x6b5e0202, 0x6c5e0202, 0x6d5e0202, 0x6e5e0202, 0x6f5e0202, 0x705e0202, 0x715e0202, + 0x725e0202, 0x735e0202, 0x745e0202, 0x755e0202, 0x765e0202, 0x775e0202, 0x785e0202, 0x795e0202, + 0x7a5e0202, 0x7b5e0202, 0x7c5e0202, 0x7d5e0202, 0x7e5e0202, 0x7f5e0202, 0x805e0202, 0x815e0202, + 0x825e0202, 0x835e0202, 0x845e0202, 0x855e0202, 0x865e0202, 0x875e0202, 0x885e0202, 0x895e0202, + 0x8a5e0202, 0x8b5e0202, 0x8c5e0202, 0x8d5e0202, 0x8e5e0202, 0x8f5e0202, 0x915e0202, 0x925e0202, + 0x935e0202, 0x945e0202, 0x955e0202, 0x965e0202, 0x975e0202, 0x985e0202, 0x995e0202, 0x9a5e0202, + 0x9b5e0202, 0x9c5e0202, 0x9d5e0202, 0x9e5e0202, 0x9f5e0202, 0xa05e0202, 0xa15e0202, 0xa25e0202, + 0xa35e0202, 0xa45e0202, 0xa55e0202, 0xa65e0202, 0xa75e0202, 0xa85e0202, 0xa95e0202, 0xaa5e0202, + 0xab5e0202, 0xac5e0202, 0xad5e0202, 0xae5e0202, 0xaf5e0202, 0xb05e0202, 0xb15e0202, 0xb25e0202, + 0xb35e0202, 0xb45e0202, 0xb55e0202, 0xb65e0202, 0xb75e0202, 0xb85e0202, 0xb95e0202, 0xba5e0202, + 0xbb5e0202, 0xbc5e0202, 0xbd5e0202, 0xbe5e0202, 0xbf5e0202, 0xc15e0202, 0xc25e0202, 0xc35e0202, + 0xc45e0202, 0xc55e0202, 0xc65e0202, 0xc75e0202, 0xc85e0202, 0xc95e0202, 0xca5e0202, 0xcb5e0202, + 0xcc5e0202, 0xcd5e0202, 0xce5e0202, 0xcf5e0202, 0xd05e0202, 0xd15e0202, 0xd25e0202, 0xd35e0202, + 0xd45e0202, 0xd55e0202, 0xd65e0202, 0xd75e0202, 0xd95e0202, 0xda5e0202, 0xdb5e0202, 0xdc5e0202, + 0xdd5e0202, 0xde5e0202, 0xe05e0202, 0xe15e0202, 0xe25e0202, 0xe35e0202, 0xe45e0202, 0xe55e0202, + 0xe65e0202, 0xe85e0202, 0xe95e0202, 0xea5e0202, 0xeb5e0202, 0xec5e0202, 0xed5e0202, 0xee5e0202, + 0xef5e0202, 0xf05e0202, 0xf15e0202, 0xf25e0202, 0xf35e0202, 0xf45e0202, 0xf55e0202, 0xf65e0202, + 0xf75e0202, 0xf85e0202, 0xf95e0202, 0xfa5e0202, 0xfb5e0202, 0xfc5e0202, 0xfd5e0202, 0xfe5e0202, + 0xff5e0202, 0x025f0202, 0x035f0202, 0x045f0202, 0x055f0202, 0x065f0202, 0x075f0202, 0x085f0202, + 0x095f0202, 0x0a5f0202, 0x0b5f0202, 0x0c5f0202, 0x0d5f0202, 0x0e5f0202, 0x0f5f0202, 0x105f0202, + 0x115f0202, 0x125f0202, 0x135f0202, 0x145f0202, 0x155f0202, 0x165f0202, 0x175f0202, 0x185f0202, + 0x195f0202, 0x1a5f0202, 0x1b5f0202, 0x1c5f0202, 0x1d5f0202, 0x31070302, 0x34070302, 0x3c073d02, + 0x5f5e0302, 0x745e0302, 0x925e0302, 0x0f5e0202, 0x225e0202, 0x385e0202, 0x4d5e0202, 0x595e0202, + 0x605e0202, 0x635e0202, 0x6a5e0202, 0x905e0202, 0xc05e0202, 0xd85e0202, 0xdf5e0202, 0xe75e0202, + 0x030d2102, 0x1a0d2102, 0x1c0d2102, 0x1e0d2102, 0x200d2102, 0x220d2102, 0x240d2102, 0x260d2102, + 0x280d2102, 0x2a0d2102, 0x785e0302, 0xde5e0302, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xf5100212, 0xf5100202, 0xf6100212, 0xf6100202, 0x21100212, 0x21100202, 0x27100212, 0x27100202, + 0x2d100212, 0x2d100202, 0x6a100212, 0x6a100202, 0xd9100212, 0xd9100202, 0xfd100212, 0xfd100202, + 0x8b100212, 0x8b100202, 0xaf100212, 0xaf100202, 0xa3100212, 0xa3100202, 0xa4100212, 0xa4100202, + 0xb5100212, 0xb5100202, 0xbb100212, 0xbb100202, 0xb8100212, 0xb8100202, 0xca100212, 0xca100202, + 0x00000000, 0x00000000, 0xf3100212, 0xf3100202, 0x35100212, 0x35100202, 0xe8100212, 0xe8100202, + 0x48100412, 0x48100402, 0x48100512, 0x48100502, 0x48100612, 0x48100602, 0x48100702, 0x00019900, + 0x970d0202, 0x980d0202, 0x990d0202, 0x2d070302, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00019a00, 0x00019b00, 0x46070302, 0xff100202, + 0xf2100212, 0xf2100202, 0xf1100212, 0xf1100202, 0xf4100212, 0xf4100202, 0xfc100212, 0xfc100202, + 0xee100212, 0xee100202, 0x5c100212, 0x5c100202, 0x58100212, 0x58100202, 0xfa100212, 0xfa100202, + 0x76100212, 0x76100202, 0xfb100212, 0xfb100202, 0x41100212, 0x41100202, 0x85100212, 0x85100202, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x02680202, 0x03680202, 0x04680202, 0x05680202, 0x06680202, 0x07680202, 0x08680202, 0x09680202, + 0x0a680202, 0x0b680202, 0x0c680202, 0x0d680202, 0x0e680202, 0x0f680202, 0x10680202, 0x11680202, + 0x12680202, 0x13680202, 0x14680202, 0x15680202, 0x16680202, 0x17680202, 0x18680202, 0x19680202, + 0x1a680202, 0x1b680202, 0x1c680202, 0x1d680202, 0x1e680202, 0x1f680202, 0x20680202, 0x21680202, + 0x22680202, 0x23680202, 0x24680202, 0x25680202, 0x26680202, 0x27680202, 0x28680202, 0x29680202, + 0x2a680202, 0x2b680202, 0x2c680202, 0x2d680202, 0x2e680202, 0x2f680202, 0x30680202, 0x31680202, + 0x32680202, 0x33680202, 0x34680202, 0x35680202, 0x36680202, 0x37680202, 0x38680202, 0x39680202, + 0x3a680202, 0x3b680202, 0x3c680202, 0x3d680202, 0x3e680202, 0x3f680202, 0x40680202, 0x41680202, + 0x42680202, 0x43680202, 0x44680202, 0x45680202, 0x46680202, 0x47680202, 0x1a0d2c02, 0x1c0d2b02, + 0x1e0d2b02, 0x200d2902, 0x220d2902, 0x240d2a02, 0x260d2902, 0x280d2902, 0x2a0d2902, 0x030d2b02, + 0x00015100, 0x00015200, 0x46070402, 0x46070502, 0x46070602, 0x46070702, 0x46070802, 0x46070902, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x96a80202, 0x97a80202, 0x98a80202, 0x99a80202, 0x9aa80202, 0x9ba80202, 0x9ca80202, 0x9da80202, + 0x9ea80202, 0x9fa80202, 0xa0a80202, 0xa1a80202, 0xa2a80202, 0xa3a80202, 0xa4a80202, 0xa5a80202, + 0xa6a80202, 0xa7a80202, 0xa8a80202, 0xa9a80202, 0xaaa80202, 0xaba80202, 0xaca80202, 0xada80202, + 0xaea80202, 0xafa80202, 0xb0a80202, 0xb6a80202, 0xb7a80202, 0xb8a80202, 0xb9a80202, 0xbaa80202, + 0xb1a80202, 0xb2a80202, 0xb30e1112, 0xb30e1102, 0xe10e0212, 0xe10e0202, 0x310e0212, 0x310e0202, + 0x990e7e12, 0x990e7e02, 0xb30e0e12, 0xb30e0e02, 0xb30e0f12, 0xb30e0f02, 0xb30e1012, 0xb30e1002, + 0x230e0216, 0x910e0216, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0a0e1112, 0x0a0e1102, + 0x360e7c12, 0x360e7c02, 0x360e7d12, 0x360e7d02, 0x360e7e12, 0x360e7e02, 0x480e6e12, 0x480e6e02, + 0x480e6f12, 0x480e6f02, 0x7c0e6b12, 0x7c0e6b02, 0x7c0e6912, 0x7c0e6902, 0x00000000, 0x00000000, + 0x7e0e5712, 0x7e0e5702, 0x7e0e5812, 0x7e0e5802, 0x7e0e5912, 0x7e0e5902, 0x890ef312, 0x890ef302, + 0x890ef412, 0x890ef402, 0x8a0e8312, 0x8a0e8302, 0x8a0e8712, 0x8a0e8702, 0xa20e7d12, 0xa20e7d02, + 0x00000000, 0x00000000, 0xa90e7f12, 0xa90e7f02, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xdc0e0212, 0xdc0e0202, 0xdd0e0212, 0xdd0e0202, 0xde0e0212, 0xde0e0202, 0xdf0e0212, 0xdf0e0202, + 0xdf0e020a, 0x1f0e0202, 0x4b0e0202, 0x510e5902, 0x730e0202, 0x8a0e8602, 0x8a0e8616, 0x990e7f02, + 0xe00e0202, 0x1a0ecd12, 0x1a0ecd02, 0x230e1112, 0x230e1102, 0x260e0a12, 0x250e0b12, 0x250e0b02, + 0x480e7012, 0x480e7002, 0x8a0e8212, 0x8a0e8202, 0x970e0212, 0x970e0202, 0x990e6e12, 0x990e6e02, + 0xb3a80202, 0xb4a80202, 0xb5a80202, 0xb30e1212, 0xb30e1202, 0x2c0e7c03, 0xe20e0202, 0x00000000, + 0xe30e0212, 0xe30e0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x250e1812, 0x250e1802, 0x360e1d12, 0x360e1d02, 0x700e1d12, 0x700e1d02, 0xe30e0312, 0xe30e0302, + 0xe30e0412, 0xe30e0402, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0xe40e0202, 0x230e0a12, 0x7e0e5a02, 0x510e7d12, 0x320e0802, 0xc40e0202, + 0x024b0202, 0x034b0202, 0x044b0202, 0x054b0202, 0x064b0202, 0x074b0202, 0x084b0202, 0x094b0202, + 0x0a4b0202, 0x0b4b0202, 0x0c4b0202, 0x0d4b0202, 0x0e4b0202, 0x0f4b0202, 0x104b0202, 0x114b0202, + 0x124b0202, 0x134b0202, 0x144b0202, 0x154b0202, 0x164b0202, 0x174b0202, 0x184b0202, 0x194b0202, + 0x1a4b0202, 0x1b4b0202, 0x1c4b0202, 0x1d4b0202, 0x1e4b0202, 0x1f4b0202, 0x204b0202, 0x214b0202, + 0x224b0202, 0x234b0202, 0x244b0202, 0x254b0202, 0x264b0202, 0x274b0202, 0x284b0202, 0x294b0202, + 0x9b0c0202, 0x9c0c0202, 0x9d0c0202, 0x9e0c0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x0d0d0e04, 0x110de104, 0x150d0e04, 0x030dec03, 0x090d0204, 0x0b0d0303, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x82530202, 0x84530202, 0x86530202, 0x88530202, 0x8a530202, 0x8c530202, 0x8e530202, 0x90530202, + 0x92530202, 0x94530202, 0x96530202, 0x98530202, 0x9a530202, 0x9c530202, 0x9e530202, 0xa0530202, + 0xa2530202, 0xa4530202, 0xa6530202, 0xa8530202, 0xaa530202, 0xac530202, 0xae530202, 0xb0530202, + 0xb2530202, 0xb4530202, 0xb6530202, 0xb8530202, 0xba530202, 0xbc530202, 0xbe530202, 0xc0530202, + 0xc2530202, 0xc4530202, 0xc6530202, 0xc8530202, 0xca530202, 0xcc530202, 0xce530202, 0xd0530202, + 0xd2530202, 0xd4530202, 0xd6530202, 0xd8530202, 0xda530202, 0xdc530202, 0xde530202, 0xe0530202, + 0xe2530202, 0xe4530202, 0xe6530202, 0xe8530202, 0xf6070202, 0xf7070202, 0xf8070202, 0xf9070202, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x02600202, 0x03600202, 0x0c600202, 0x0d600202, 0x0e600202, 0x0f600202, 0x10600202, 0x11600202, + 0x12600202, 0x13600202, 0x14600202, 0x15600202, 0x16600202, 0x17600202, 0x18600202, 0x19600202, + 0x1a600202, 0x1b600202, 0x1c600202, 0x1d600202, 0x1e600202, 0x1f600202, 0x20600202, 0x21600202, + 0x22600202, 0x23600202, 0x24600202, 0x25600202, 0x26600202, 0x27600202, 0x28600202, 0x29600202, + 0x2a600202, 0x2b600202, 0x2c600202, 0x2d600202, 0x2e600202, 0x2f600202, 0x30600202, 0x31600202, + 0x32600202, 0x33600202, 0x34600202, 0x35600202, 0x36600202, 0x37600202, 0x38600202, 0x39600202, + 0x3a600202, 0x3b600202, 0x3c600202, 0x3d600202, 0x3e600202, 0x3f600202, 0x40600202, 0x41600202, + 0x42600202, 0x43600202, 0x44600202, 0x45600202, 0x46600202, 0x47600202, 0x48600202, 0x49600202, + 0x4a600202, 0x4b600202, 0x4c600202, 0x4d600202, 0x4e600202, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xdf070202, 0xe0070202, + 0x030d2202, 0x1a0d2202, 0x1c0d2202, 0x1e0d2202, 0x200d2202, 0x220d2202, 0x240d2202, 0x260d2202, + 0x280d2202, 0x2a0d2202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0xfe320202, 0xfe320203, 0xfe320203, 0xfe320203, 0xfe320203, 0xfe320203, + 0x00000000, 0x00000000, 0x00000000, 0xff320202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x030d2302, 0x1a0d2302, 0x1c0d2302, 0x1e0d2302, 0x200d2302, 0x220d2302, 0x240d2302, 0x260d2302, + 0x280d2302, 0x2a0d2302, 0x02610202, 0x03610202, 0x04610202, 0x05610202, 0x06610202, 0x07610202, + 0x08610202, 0x09610202, 0x0a610202, 0x0b610202, 0x0c610202, 0x0d610202, 0x0e610202, 0x0f610202, + 0x10610202, 0x11610202, 0x12610202, 0x13610202, 0x14610202, 0x15610202, 0x16610202, 0x17610202, + 0x18610202, 0x19610202, 0x1a610202, 0x1b610202, 0x1c610202, 0x1d610202, 0x1e610202, 0x1f610202, + 0x20610202, 0x21610202, 0x22610202, 0x00010300, 0x00010400, 0x00010500, 0xf1070202, 0xf2070202, + 0x02620202, 0x03620202, 0x04620202, 0x05620202, 0x06620202, 0x07620202, 0x08620202, 0x09620202, + 0x0a620202, 0x0b620202, 0x0c620202, 0x0d620202, 0x0e620202, 0x0f620202, 0x10620202, 0x11620202, + 0x12620202, 0x13620202, 0x14620202, 0x15620202, 0x16620202, 0x17620202, 0x18620202, 0x19620202, + 0x1a620202, 0x1b620202, 0x1c620202, 0x1d620202, 0x1e620202, 0x1f620202, 0x20620202, 0x21620202, + 0x22620202, 0x23620202, 0x24620202, 0x25620202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xfd070202, + 0xae042002, 0xae042602, 0xae042c02, 0xae043802, 0xb0040802, 0xb0040e02, 0xb0042602, 0xb0042c02, + 0xb0044402, 0xb0045c02, 0xb0046802, 0xb0048002, 0xb0048602, 0xb0049e02, 0xb004a402, 0xb4040802, + 0xb4041a02, 0xb4043802, 0xb8045602, 0xb8046802, 0xb8047a02, 0xbe044a02, 0xca042002, 0xca047402, + 0xce042002, 0xe0040802, 0xe2041a02, 0xe6042002, 0xe8040802, 0x00000000, 0x00000000, 0x00000000, + 0x6c540402, 0x6c540502, 0x6c540602, 0x6c540702, 0x02690202, 0x03690202, 0x04690202, 0x05690202, + 0x06690202, 0x07690202, 0x08690202, 0x09690202, 0x0a690202, 0x0b690202, 0x0c690202, 0x0d690202, + 0x0e690202, 0x0f690202, 0x10690202, 0x11690202, 0x12690202, 0x13690202, 0x14690202, 0x15690202, + 0x16690202, 0x17690202, 0x18690202, 0x19690202, 0x1a690202, 0x1b690202, 0x1c690202, 0x1d690202, + 0x1e690202, 0x1f690202, 0x20690202, 0x21690202, 0x22690202, 0x23690202, 0x24690202, 0x25690202, + 0x26690202, 0x27690202, 0x28690202, 0x2a690202, 0x2a690203, 0x2c690202, 0x2d690202, 0x2e690202, + 0x2f690202, 0x30690202, 0x31690202, 0x6c540302, 0x32690202, 0x3b690202, 0x34690202, 0x35690202, + 0x36690202, 0x37690202, 0x39690202, 0x3a690202, 0x33690202, 0x38690202, 0x29690202, 0x2b690202, + 0x3c690202, 0xfd070302, 0xfd070402, 0xfd070502, 0xfd070602, 0xfd070702, 0xfd070802, 0xfd070902, + 0xfd070a02, 0xfd070b02, 0xfd070c02, 0xfd070d02, 0xfd070e02, 0xfd070f02, 0x00000000, 0x02690202, + 0x030d2902, 0x1a0d2b02, 0x1c0d2a02, 0x1e0d2a02, 0x200d2802, 0x220d2802, 0x240d2902, 0x260d2802, + 0x280d2802, 0x2a0d2802, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xfd071002, 0xfd071102, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x02630202, 0x03630202, 0x04630202, 0x05630202, 0x06630202, 0x07630202, 0x08630202, 0x09630202, + 0x0a630202, 0x0b630202, 0x0c630202, 0x0d630202, 0x0e630202, 0x0f630202, 0x10630202, 0x11630202, + 0x12630202, 0x13630202, 0x14630202, 0x15630202, 0x16630202, 0x17630202, 0x18630202, 0x19630202, + 0x1a630202, 0x1b630202, 0x1c630202, 0x1d630202, 0x1e630202, 0x1f630202, 0x20630202, 0x21630202, + 0x22630202, 0x23630202, 0x24630202, 0x25630202, 0x26630202, 0x27630202, 0x28630202, 0x29630202, + 0x2a630202, 0x2f630202, 0x30630202, 0x31630202, 0x32630202, 0x33630202, 0x34630202, 0x35630202, + 0x36630202, 0x37630202, 0x38630202, 0x2b630202, 0x2c630202, 0x2d630202, 0x2e630202, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x39630202, 0x3a630202, 0x3b630202, 0x3c630202, 0x3d630202, 0x3e630202, 0x3f630202, 0x40630202, + 0x41630202, 0x42630202, 0x43630202, 0x44630202, 0x45630202, 0x46630202, 0x00000000, 0x00000000, + 0x030d2402, 0x1a0d2402, 0x1c0d2402, 0x1e0d2402, 0x200d2402, 0x220d2402, 0x240d2402, 0x260d2402, + 0x280d2402, 0x2a0d2402, 0x00000000, 0x00000000, 0xde070202, 0xdf070202, 0xe0070202, 0xe1070202, + 0x093e0202, 0x0f3e0202, 0x113e0202, 0x133e0202, 0x183e0202, 0x1c3e0202, 0x1f3e0202, 0x213e0202, + 0x233e0202, 0x253e0202, 0x2e3e0202, 0x313e0202, 0x4d3e0202, 0x503e0202, 0x523e0202, 0x373e0202, + 0xb43e0202, 0x533e0202, 0x153e0202, 0x413e0202, 0xaf3e0202, 0xb03e0202, 0xb13e0202, 0xe1070302, + 0xe1070402, 0xe1070502, 0x423e0202, 0xa83e0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x02650202, 0x03650202, 0x04650202, 0x05650202, 0x06650202, 0x07650202, 0x08650202, 0x09650202, + 0x0a650202, 0x0b650202, 0x0c650202, 0x0d650202, 0x0e650202, 0x0f650202, 0x10650202, 0x11650202, + 0x12650202, 0x13650202, 0x14650202, 0x15650202, 0x16650202, 0x17650202, 0x18650202, 0x19650202, + 0x1a650202, 0x1b650202, 0x1c650202, 0x1d650202, 0x1e650202, 0x1f650202, 0x20650202, 0x21650202, + 0x22650202, 0x23650202, 0x24650202, 0x25650202, 0x26650202, 0x27650202, 0x28650202, 0x29650202, + 0x2a650202, 0x2b650202, 0x2c650202, 0x2d650202, 0x2e650202, 0x2f650202, 0x30650202, 0x31650202, + 0x32650202, 0x33650202, 0x34650202, 0x35650202, 0x36650202, 0x37650202, 0x38650202, 0x39650202, + 0x3a650202, 0x3b650202, 0x3c650202, 0x3d650202, 0x3e650202, 0x3f650202, 0x40650202, 0x72410302, + 0x41650202, 0x72410402, 0x42650202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x43650202, 0x44650202, 0x02650202, 0xe1070602, 0xe1070702, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0xe9530202, 0xea530202, 0xeb530202, 0xec530202, 0xed530202, 0xee530202, 0x00000000, + 0x00000000, 0xf5530202, 0xf6530202, 0xf7530202, 0xf8530202, 0xf9530202, 0xfa530202, 0x00000000, + 0x00000000, 0xef530202, 0xf0530202, 0xf1530202, 0xf2530202, 0xf3530202, 0xf4530202, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x2b530302, 0x2b530402, 0x2b530502, 0x2b530602, 0x2b530702, 0x2b530802, 0x2b530902, 0x00000000, + 0xe8520302, 0xe8520402, 0xe8520502, 0xe8520602, 0xe8520702, 0xe8520802, 0xe8520902, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x026a0202, 0x036a0202, 0x046a0202, 0x056a0202, 0x066a0202, 0x076a0202, 0x086a0202, 0x096a0202, + 0x0a6a0202, 0x0b6a0202, 0x0c6a0202, 0x0d6a0202, 0x0e6a0202, 0x0f6a0202, 0x106a0202, 0x116a0202, + 0x126a0202, 0x136a0202, 0x146a0202, 0x156a0202, 0x166a0202, 0x176a0202, 0x186a0202, 0x196a0202, + 0x1a6a0202, 0x1b6a0202, 0x1c6a0202, 0x256a0202, 0x266a0202, 0x276a0202, 0x286a0202, 0x296a0202, + 0x2a6a0202, 0x2b6a0202, 0x2c6a0202, 0x1d6a0202, 0x1e6a0202, 0x1f6a0202, 0x206a0202, 0x216a0202, + 0x226a0202, 0x236a0202, 0x246a0202, 0xe1070802, 0x045b0302, 0x2d6a0202, 0x00000000, 0x00000000, + 0x030d2602, 0x1a0d2702, 0x1c0d2702, 0x1e0d2702, 0x200d2502, 0x220d2502, 0x240d2602, 0x260d2502, + 0x280d2502, 0x2a0d2502, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x03c00202, 0x04c00202, 0x05c00202, 0x06c00202, 0x07c00202, 0x08c00202, 0x09c00202, 0x0ac00202, + 0x0bc00202, 0x0cc00202, 0x0dc00202, 0x0ec00202, 0x0fc00202, 0x10c00202, 0x11c00202, 0x12c00202, + 0x13c00202, 0x14c00202, 0x15c00202, 0x16c00202, 0x17c00202, 0x18c00202, 0x19c00202, 0x1ac00202, + 0x1bc00202, 0x1cc00202, 0x1dc00202, 0x1ec00202, 0x1fc00202, 0x20c00202, 0x21c00202, 0x22c00202, + 0x23c00202, 0x24c00202, 0x25c00202, 0x26c00202, 0x27c00202, 0x28c00202, 0x29c00202, 0x2ac00202, + 0x2bc00202, 0x2cc00202, 0x2dc00202, 0x2ec00202, 0x2fc00202, 0x30c00202, 0x31c00202, 0x32c00202, + 0x33c00202, 0x34c00202, 0x35c00202, 0x36c00202, 0x37c00202, 0x38c00202, 0x39c00202, 0x3ac00202, + 0x3bc00202, 0x3cc00202, 0x3dc00202, 0x3ec00202, 0x3fc00202, 0x40c00202, 0x41c00202, 0x42c00202, + 0x43c00202, 0x44c00202, 0x45c00202, 0x46c00202, 0x47c00202, 0x48c00202, 0x49c00202, 0x4ac00202, + 0x4bc00202, 0x4cc00202, 0x4dc00202, 0x4ec00202, 0x4fc00202, 0x50c00202, 0x51c00202, 0x52c00202, + 0x53c00202, 0x54c00202, 0x55c00202, 0x56c00202, 0x57c00202, 0x58c00202, 0x59c00202, 0x5ac00202, + 0x5bc00202, 0x5cc00202, 0x5dc00202, 0x5ec00202, 0x5fc00202, 0x60c00202, 0x61c00202, 0x62c00202, + 0x63c00202, 0x64c00202, 0x65c00202, 0x66c00202, 0x67c00202, 0x68c00202, 0x69c00202, 0x6ac00202, + 0x6bc00202, 0x6cc00202, 0x6dc00202, 0x6ec00202, 0x6fc00202, 0x70c00202, 0x71c00202, 0x72c00202, + 0x73c00202, 0x74c00202, 0x75c00202, 0x76c00202, 0x77c00202, 0x78c00202, 0x79c00202, 0x7ac00202, + 0x7bc00202, 0x7cc00202, 0x7dc00202, 0x7ec00202, 0x7fc00202, 0x80c00202, 0x81c00202, 0x82c00202, + 0x83c00202, 0x84c00202, 0x85c00202, 0x86c00202, 0x87c00202, 0x88c00202, 0x89c00202, 0x8ac00202, + 0x8bc00202, 0x8cc00202, 0x8dc00202, 0x8ec00202, 0x8fc00202, 0x90c00202, 0x91c00202, 0x92c00202, + 0x93c00202, 0x94c00202, 0x95c00202, 0x96c00202, 0x97c00202, 0x98c00202, 0x99c00202, 0x9ac00202, + 0x9bc00202, 0x9cc00202, 0x9dc00202, 0x9ec00202, 0x9fc00202, 0xa0c00202, 0xa1c00202, 0xa2c00202, + 0xa3c00202, 0xa4c00202, 0xa5c00202, 0xa6c00202, 0xa7c00202, 0xa8c00202, 0xa9c00202, 0xaac00202, + 0xabc00202, 0xacc00202, 0xadc00202, 0xaec00202, 0xafc00202, 0xb0c00202, 0xb1c00202, 0xb2c00202, + 0xb3c00202, 0xb4c00202, 0xb5c00202, 0xb6c00202, 0xb7c00202, 0xb8c00202, 0xb9c00202, 0xbac00202, + 0xbbc00202, 0xbcc00202, 0xbdc00202, 0xbec00202, 0xbfc00202, 0xc0c00202, 0xc1c00202, 0xc2c00202, + 0xc3c00202, 0xc4c00202, 0xc5c00202, 0xc6c00202, 0xc7c00202, 0xc8c00202, 0xc9c00202, 0xcac00202, + 0xcbc00202, 0xccc00202, 0xcdc00202, 0xcec00202, 0xcfc00202, 0xd0c00202, 0xd1c00202, 0xd2c00202, + 0xd3c00202, 0xd4c00202, 0xd5c00202, 0xd6c00202, 0xd7c00202, 0xd8c00202, 0xd9c00202, 0xdac00202, + 0xdbc00202, 0xdcc00202, 0xddc00202, 0xdec00202, 0xdfc00202, 0xe0c00202, 0xe1c00202, 0xe2c00202, + 0xe3c00202, 0xe4c00202, 0xe5c00202, 0xe6c00202, 0xe7c00202, 0xe8c00202, 0xe9c00202, 0xeac00202, + 0xebc00202, 0xecc00202, 0xedc00202, 0xeec00202, 0xefc00202, 0xf0c00202, 0xf1c00202, 0xf2c00202, + 0xf3c00202, 0xf4c00202, 0xf5c00202, 0xf6c00202, 0xf7c00202, 0xf8c00202, 0xf9c00202, 0xfac00202, + 0xfbc00202, 0xfcc00202, 0xfdc00202, 0xfec00202, 0xffc00202, 0x02c10202, 0x03c10202, 0x04c10202, + 0x05c10202, 0x06c10202, 0x07c10202, 0x08c10202, 0x09c10202, 0x0ac10202, 0x0bc10202, 0x0cc10202, + 0x0dc10202, 0x0ec10202, 0x0fc10202, 0x10c10202, 0x11c10202, 0x12c10202, 0x13c10202, 0x14c10202, + 0x15c10202, 0x16c10202, 0x17c10202, 0x18c10202, 0x19c10202, 0x1ac10202, 0x1bc10202, 0x1cc10202, + 0x1dc10202, 0x1ec10202, 0x1fc10202, 0x20c10202, 0x21c10202, 0x22c10202, 0x23c10202, 0x24c10202, + 0x25c10202, 0x26c10202, 0x27c10202, 0x28c10202, 0x29c10202, 0x2ac10202, 0x2bc10202, 0x2cc10202, + 0x2dc10202, 0x2ec10202, 0x2fc10202, 0x30c10202, 0x31c10202, 0x32c10202, 0x33c10202, 0x34c10202, + 0x35c10202, 0x36c10202, 0x37c10202, 0x38c10202, 0x39c10202, 0x3ac10202, 0x3bc10202, 0x3cc10202, + 0x3dc10202, 0x3ec10202, 0x3fc10202, 0x40c10202, 0x41c10202, 0x42c10202, 0x43c10202, 0x44c10202, + 0x45c10202, 0x46c10202, 0x47c10202, 0x48c10202, 0x49c10202, 0x4ac10202, 0x4bc10202, 0x4cc10202, + 0x4dc10202, 0x4ec10202, 0x4fc10202, 0x50c10202, 0x51c10202, 0x52c10202, 0x53c10202, 0x54c10202, + 0x55c10202, 0x56c10202, 0x57c10202, 0x58c10202, 0x59c10202, 0x5ac10202, 0x5bc10202, 0x5cc10202, + 0x5dc10202, 0x5ec10202, 0x5fc10202, 0x60c10202, 0x61c10202, 0x62c10202, 0x63c10202, 0x64c10202, + 0x65c10202, 0x66c10202, 0x67c10202, 0x68c10202, 0x69c10202, 0x6ac10202, 0x6bc10202, 0x6cc10202, + 0x6dc10202, 0x6ec10202, 0x6fc10202, 0x70c10202, 0x71c10202, 0x73c10202, 0x74c10202, 0x75c10202, + 0x76c10202, 0x77c10202, 0x78c10202, 0x79c10202, 0x7ac10202, 0x7bc10202, 0x7cc10202, 0x7dc10202, + 0x7ec10202, 0x7fc10202, 0x80c10202, 0x81c10202, 0x82c10202, 0x83c10202, 0x84c10202, 0x85c10202, + 0x86c10202, 0x87c10202, 0x88c10202, 0x89c10202, 0x8ac10202, 0x8bc10202, 0x8cc10202, 0x8dc10202, + 0x8ec10202, 0x8fc10202, 0x90c10202, 0x91c10202, 0x92c10202, 0x93c10202, 0x94c10202, 0x95c10202, + 0x96c10202, 0x97c10202, 0x98c10202, 0x99c10202, 0x9ac10202, 0x9bc10202, 0x9cc10202, 0x9dc10202, + 0x9ec10202, 0x9fc10202, 0xa0c10202, 0xa1c10202, 0xa2c10202, 0xa3c10202, 0xa4c10202, 0xa5c10202, + 0xa6c10202, 0xa7c10202, 0xa8c10202, 0xa9c10202, 0xaac10202, 0xabc10202, 0xacc10202, 0xadc10202, + 0xaec10202, 0xafc10202, 0xb0c10202, 0xb1c10202, 0xb2c10202, 0xb3c10202, 0xb4c10202, 0xb5c10202, + 0xb6c10202, 0xb7c10202, 0xb8c10202, 0xb9c10202, 0xbac10202, 0xbbc10202, 0xbcc10202, 0xbdc10202, + 0xbec10202, 0xbfc10202, 0xc0c10202, 0xc1c10202, 0xc2c10202, 0xc3c10202, 0xc4c10202, 0xc5c10202, + 0xc6c10202, 0xc7c10202, 0xc8c10202, 0xc9c10202, 0xcac10202, 0xcbc10202, 0xccc10202, 0xcdc10202, + 0xcec10202, 0xcfc10202, 0xd0c10202, 0xd1c10202, 0xd2c10202, 0xd3c10202, 0xd4c10202, 0xd5c10202, + 0xd6c10202, 0xd7c10202, 0xd8c10202, 0xd9c10202, 0xdac10202, 0xdbc10202, 0xdcc10202, 0xddc10202, + 0xdec10202, 0xdfc10202, 0xe0c10202, 0xe1c10202, 0xe2c10202, 0xe3c10202, 0xe4c10202, 0xe5c10202, + 0xe6c10202, 0xe7c10202, 0xe8c10202, 0xe9c10202, 0xeac10202, 0xebc10202, 0xecc10202, 0xedc10202, + 0xeec10202, 0xefc10202, 0xf0c10202, 0xf1c10202, 0xf2c10202, 0xf3c10202, 0xf4c10202, 0xf5c10202, + 0xf6c10202, 0xf7c10202, 0xf8c10202, 0xf9c10202, 0xfac10202, 0xfbc10202, 0xfcc10202, 0xfdc10202, + 0xfec10202, 0xffc10202, 0x02c20202, 0x03c20202, 0x04c20202, 0x05c20202, 0x06c20202, 0x07c20202, + 0x08c20202, 0x09c20202, 0x0ac20202, 0x0bc20202, 0x0cc20202, 0x0dc20202, 0x0ec20202, 0x0fc20202, + 0x10c20202, 0x11c20202, 0x12c20202, 0x13c20202, 0x14c20202, 0x15c20202, 0x16c20202, 0x17c20202, + 0x18c20202, 0x19c20202, 0x1ac20202, 0x1bc20202, 0x1cc20202, 0x1dc20202, 0x1ec20202, 0x1fc20202, + 0x20c20202, 0x21c20202, 0x22c20202, 0x23c20202, 0x24c20202, 0x25c20202, 0x26c20202, 0x27c20202, + 0x28c20202, 0x29c20202, 0x2ac20202, 0x2bc20202, 0x2cc20202, 0x2dc20202, 0x2ec20202, 0x2fc20202, + 0x30c20202, 0x31c20202, 0x32c20202, 0x33c20202, 0x34c20202, 0x35c20202, 0x36c20202, 0x37c20202, + 0x38c20202, 0x3ac20202, 0x3bc20202, 0x3cc20202, 0x3dc20202, 0x3ec20202, 0x3fc20202, 0x40c20202, + 0x41c20202, 0x42c20202, 0x43c20202, 0x44c20202, 0x45c20202, 0x46c20202, 0x47c20202, 0x48c20202, + 0x49c20202, 0x4ac20202, 0x4bc20202, 0x4cc20202, 0x4dc20202, 0x4ec20202, 0x4fc20202, 0x50c20202, + 0x51c20202, 0x52c20202, 0x53c20202, 0x54c20202, 0x56c20202, 0x57c20202, 0x58c20202, 0x59c20202, + 0x5ac20202, 0x5bc20202, 0x5cc20202, 0x5dc20202, 0x5ec20202, 0x5fc20202, 0x60c20202, 0x61c20202, + 0x62c20202, 0x63c20202, 0x64c20202, 0x65c20202, 0x66c20202, 0x67c20202, 0x68c20202, 0x69c20202, + 0x6ac20202, 0x6bc20202, 0x6cc20202, 0x6dc20202, 0x6ec20202, 0x6fc20202, 0x70c20202, 0x71c20202, + 0x72c20202, 0x73c20202, 0x74c20202, 0x75c20202, 0x76c20202, 0x77c20202, 0x78c20202, 0x79c20202, + 0x7ac20202, 0x7bc20202, 0x7cc20202, 0x7dc20202, 0x7ec20202, 0x7fc20202, 0x80c20202, 0x81c20202, + 0x82c20202, 0x83c20202, 0x84c20202, 0x85c20202, 0x86c20202, 0x87c20202, 0x88c20202, 0x89c20202, + 0x8ac20202, 0x8bc20202, 0x8cc20202, 0x8dc20202, 0x8ec20202, 0x8fc20202, 0x90c20202, 0x91c20202, + 0x92c20202, 0x93c20202, 0x94c20202, 0x95c20202, 0x96c20202, 0x97c20202, 0x98c20202, 0x99c20202, + 0x9ac20202, 0x9bc20202, 0x9cc20202, 0x9dc20202, 0x9ec20202, 0x9fc20202, 0xa0c20202, 0xa1c20202, + 0xa2c20202, 0xa3c20202, 0xa4c20202, 0xa5c20202, 0xa6c20202, 0xa7c20202, 0xa8c20202, 0xa9c20202, + 0xaac20202, 0xabc20202, 0xacc20202, 0xadc20202, 0xaec20202, 0xafc20202, 0xb0c20202, 0xb1c20202, + 0xb2c20202, 0xb3c20202, 0xb4c20202, 0xb5c20202, 0xb6c20202, 0xb7c20202, 0xb8c20202, 0xb9c20202, + 0xbac20202, 0xbbc20202, 0xbcc20202, 0xbdc20202, 0xbec20202, 0xbfc20202, 0xc0c20202, 0xc1c20202, + 0xc2c20202, 0xc3c20202, 0xc4c20202, 0xc5c20202, 0xc6c20202, 0xc7c20202, 0xc8c20202, 0xc9c20202, + 0xcac20202, 0xcbc20202, 0xccc20202, 0xcdc20202, 0xcec20202, 0xcfc20202, 0xd0c20202, 0xd1c20202, + 0xd2c20202, 0xd3c20202, 0xd4c20202, 0xd5c20202, 0xd6c20202, 0xd7c20202, 0xd8c20202, 0xd9c20202, + 0xdac20202, 0xdbc20202, 0xdcc20202, 0xddc20202, 0xdec20202, 0xdfc20202, 0xe0c20202, 0xe1c20202, + 0xe2c20202, 0xe3c20202, 0xe4c20202, 0xe5c20202, 0xe6c20202, 0xe7c20202, 0xe8c20202, 0xe9c20202, + 0xeac20202, 0xebc20202, 0xecc20202, 0xedc20202, 0xeec20202, 0xefc20202, 0xf0c20202, 0xf1c20202, + 0xf2c20202, 0xf3c20202, 0xf4c20202, 0xf5c20202, 0xf6c20202, 0xf7c20202, 0xf8c20202, 0xf9c20202, + 0xfac20202, 0xfbc20202, 0xfcc20202, 0xfdc20202, 0xfec20202, 0xffc20202, 0x02c30202, 0x03c30202, + 0x04c30202, 0x05c30202, 0x06c30202, 0x07c30202, 0x08c30202, 0x09c30202, 0x0ac30202, 0x0bc30202, + 0x0cc30202, 0x0dc30202, 0x0ec30202, 0x0fc30202, 0x10c30202, 0x11c30202, 0x12c30202, 0x13c30202, + 0x14c30202, 0x15c30202, 0x16c30202, 0x17c30202, 0x18c30202, 0x19c30202, 0x1ac30202, 0x1bc30202, + 0x1cc30202, 0x1dc30202, 0x1ec30202, 0x1fc30202, 0x20c30202, 0x21c30202, 0x22c30202, 0x23c30202, + 0x24c30202, 0x25c30202, 0x26c30202, 0x27c30202, 0x28c30202, 0x29c30202, 0x2ac30202, 0x2bc30202, + 0x2cc30202, 0x2dc30202, 0x2ec30202, 0x2fc30202, 0x30c30202, 0x31c30202, 0x32c30202, 0x33c30202, + 0x34c30202, 0x35c30202, 0x36c30202, 0x37c30202, 0x38c30202, 0x39c30202, 0x3ac30202, 0x3bc30202, + 0x3cc30202, 0x3dc30202, 0x3ec30202, 0x3fc30202, 0x40c30202, 0x41c30202, 0x42c30202, 0x43c30202, + 0x44c30202, 0x45c30202, 0x46c30202, 0x47c30202, 0x48c30202, 0x49c30202, 0x4ac30202, 0x4bc30202, + 0x4cc30202, 0x4dc30202, 0x4ec30202, 0x4fc30202, 0x50c30202, 0x51c30202, 0x52c30202, 0x53c30202, + 0x54c30202, 0x55c30202, 0x56c30202, 0x57c30202, 0x58c30202, 0x59c30202, 0x5ac30202, 0x5bc30202, + 0x5cc30202, 0x5dc30202, 0x5ec30202, 0x5fc30202, 0x60c30202, 0x61c30202, 0x62c30202, 0x63c30202, + 0x64c30202, 0x65c30202, 0x66c30202, 0x67c30202, 0x68c30202, 0x69c30202, 0x6ac30202, 0x6bc30202, + 0x6cc30202, 0x6dc30202, 0x6ec30202, 0x6fc30202, 0x70c30202, 0x71c30202, 0x72c30202, 0x73c30202, + 0x74c30202, 0x75c30202, 0x76c30202, 0x77c30202, 0x78c30202, 0x79c30202, 0x7ac30202, 0x7bc30202, + 0x7cc30202, 0x7dc30202, 0x7ec30202, 0x7fc30202, 0x80c30202, 0x81c30202, 0x82c30202, 0x83c30202, + 0x84c30202, 0x85c30202, 0x86c30202, 0x87c30202, 0x88c30202, 0x89c30202, 0x8ac30202, 0x8bc30202, + 0x8cc30202, 0x8dc30202, 0x8ec30202, 0x8fc30202, 0x90c30202, 0x91c30202, 0x92c30202, 0x93c30202, + 0x94c30202, 0x95c30202, 0x96c30202, 0x97c30202, 0x98c30202, 0x99c30202, 0x9ac30202, 0x9bc30202, + 0x9cc30202, 0x9dc30202, 0x9ec30202, 0x9fc30202, 0xa0c30202, 0xa1c30202, 0xa2c30202, 0xa3c30202, + 0xa4c30202, 0xa5c30202, 0xa6c30202, 0xa7c30202, 0xa8c30202, 0xa9c30202, 0xaac30202, 0xabc30202, + 0xacc30202, 0xadc30202, 0xaec30202, 0xafc30202, 0xb0c30202, 0xb1c30202, 0xb2c30202, 0xb3c30202, + 0xb4c30202, 0xb5c30202, 0xb6c30202, 0xb7c30202, 0xb8c30202, 0xb9c30202, 0xbac30202, 0xbbc30202, + 0xbcc30202, 0xbdc30202, 0xbec30202, 0xbfc30202, 0xc0c30202, 0xc1c30202, 0xc2c30202, 0xc3c30202, + 0xc4c30202, 0xc5c30202, 0xc6c30202, 0xc7c30202, 0xc8c30202, 0xc9c30202, 0xcac30202, 0xcbc30202, + 0xccc30202, 0xcdc30202, 0xcec30202, 0xcfc30202, 0xd0c30202, 0xd1c30202, 0xd2c30202, 0xd3c30202, + 0xd4c30202, 0xd5c30202, 0xd6c30202, 0xd7c30202, 0xd8c30202, 0xd9c30202, 0xdac30202, 0xdbc30202, + 0xdcc30202, 0xddc30202, 0xdec30202, 0xdfc30202, 0xe0c30202, 0xe1c30202, 0xe2c30202, 0xe3c30202, + 0xe4c30202, 0xe5c30202, 0xe6c30202, 0xe7c30202, 0xe8c30202, 0xe9c30202, 0xeac30202, 0xebc30202, + 0xecc30202, 0xedc30202, 0xeec30202, 0xefc30202, 0xf0c30202, 0xf1c30202, 0xf2c30202, 0xf3c30202, + 0xf4c30202, 0xf5c30202, 0xf6c30202, 0xf7c30202, 0xf8c30202, 0xf9c30202, 0xfac30202, 0xfbc30202, + 0xfcc30202, 0xfdc30202, 0xfec30202, 0xffc30202, 0x02c40202, 0x03c40202, 0x04c40202, 0x05c40202, + 0x06c40202, 0x07c40202, 0x08c40202, 0x09c40202, 0x0ac40202, 0x0bc40202, 0x0cc40202, 0x0dc40202, + 0x0ec40202, 0x0fc40202, 0x10c40202, 0x11c40202, 0x12c40202, 0x13c40202, 0x14c40202, 0x15c40202, + 0x16c40202, 0x17c40202, 0x18c40202, 0x19c40202, 0x1ac40202, 0x1bc40202, 0x1cc40202, 0x1dc40202, + 0x1ec40202, 0x1fc40202, 0x20c40202, 0x21c40202, 0x22c40202, 0x23c40202, 0x24c40202, 0x25c40202, + 0x26c40202, 0x27c40202, 0x28c40202, 0x29c40202, 0x2ac40202, 0x2bc40202, 0x2cc40202, 0x2dc40202, + 0x2ec40202, 0x2fc40202, 0x30c40202, 0x31c40202, 0x32c40202, 0x33c40202, 0x34c40202, 0x35c40202, + 0x36c40202, 0x37c40202, 0x38c40202, 0x39c40202, 0x3ac40202, 0x3bc40202, 0x3cc40202, 0x3dc40202, + 0x3ec40202, 0x3fc40202, 0x40c40202, 0x41c40202, 0x42c40202, 0x43c40202, 0x44c40202, 0x45c40202, + 0x46c40202, 0x47c40202, 0x48c40202, 0x49c40202, 0x4ac40202, 0x4bc40202, 0x4cc40202, 0x4dc40202, + 0x4ec40202, 0x4fc40202, 0x50c40202, 0x51c40202, 0x52c40202, 0x53c40202, 0x54c40202, 0x55c40202, + 0x56c40202, 0x57c40202, 0x58c40202, 0x59c40202, 0x5ac40202, 0x5bc40202, 0x5cc40202, 0x5dc40202, + 0x5ec40202, 0x5fc40202, 0x60c40202, 0x61c40202, 0x62c40202, 0x63c40202, 0x64c40202, 0x65c40202, + 0x66c40202, 0x67c40202, 0x68c40202, 0x69c40202, 0x6ac40202, 0x6bc40202, 0x6cc40202, 0x6dc40202, + 0x6ec40202, 0x6fc40202, 0x70c40202, 0x71c40202, 0x72c40202, 0x73c40202, 0x74c40202, 0x75c40202, + 0x76c40202, 0x77c40202, 0x78c40202, 0x79c40202, 0x7ac40202, 0x7bc40202, 0x7cc40202, 0x7dc40202, + 0x7ec40202, 0x7fc40202, 0x80c40202, 0x81c40202, 0x82c40202, 0x83c40202, 0x84c40202, 0x85c40202, + 0x86c40202, 0x87c40202, 0x88c40202, 0x89c40202, 0x8ac40202, 0x8bc40202, 0x8cc40202, 0x8dc40202, + 0x8ec40202, 0x8fc40202, 0x90c40202, 0x91c40202, 0x92c40202, 0x93c40202, 0x94c40202, 0x95c40202, + 0x96c40202, 0x97c40202, 0x98c40202, 0x99c40202, 0x9ac40202, 0x9bc40202, 0x9cc40202, 0x9dc40202, + 0x9ec40202, 0x9fc40202, 0xa0c40202, 0xa1c40202, 0xa2c40202, 0xa3c40202, 0xa4c40202, 0xa5c40202, + 0xaac40202, 0xabc40202, 0xacc40202, 0xadc40202, 0xaec40202, 0xafc40202, 0xb0c40202, 0xb1c40202, + 0xb2c40202, 0xb3c40202, 0xb4c40202, 0xb5c40202, 0xb6c40202, 0xb7c40202, 0xb8c40202, 0xb9c40202, + 0xbac40202, 0xbbc40202, 0xbcc40202, 0xbdc40202, 0xbec40202, 0xbfc40202, 0xc0c40202, 0xc1c40202, + 0xc2c40202, 0xc3c40202, 0xc4c40202, 0xc5c40202, 0xc6c40202, 0xc7c40202, 0xc8c40202, 0xc9c40202, + 0xcac40202, 0xcbc40202, 0xccc40202, 0xcdc40202, 0xcec40202, 0xcfc40202, 0xd0c40202, 0xd1c40202, + 0xd2c40202, 0xd3c40202, 0xd4c40202, 0xd5c40202, 0xd6c40202, 0xd7c40202, 0xd8c40202, 0xd9c40202, + 0xdac40202, 0xdbc40202, 0xddc40202, 0xdec40202, 0xdfc40202, 0xe0c40202, 0xe1c40202, 0xe2c40202, + 0xe3c40202, 0xe4c40202, 0xe5c40202, 0xe6c40202, 0xe7c40202, 0xe8c40202, 0xe9c40202, 0xeac40202, + 0xebc40202, 0xecc40202, 0xedc40202, 0xeec40202, 0xefc40202, 0xf0c40202, 0xf1c40202, 0xf2c40202, + 0xf3c40202, 0xf4c40202, 0xf5c40202, 0xf6c40202, 0xf7c40202, 0xf8c40202, 0xf9c40202, 0xfac40202, + 0xfbc40202, 0xfcc40202, 0xfdc40202, 0xfec40202, 0xffc40202, 0x02c50202, 0x03c50202, 0x04c50202, + 0x05c50202, 0x06c50202, 0x07c50202, 0x08c50202, 0x09c50202, 0x0ac50202, 0x0bc50202, 0x0cc50202, + 0x0dc50202, 0x0ec50202, 0x0fc50202, 0x10c50202, 0x11c50202, 0x12c50202, 0x13c50202, 0x14c50202, + 0x15c50202, 0x16c50202, 0x17c50202, 0x18c50202, 0x19c50202, 0x1ac50202, 0x1bc50202, 0x1cc50202, + 0x1dc50202, 0x1ec50202, 0x1fc50202, 0x20c50202, 0x21c50202, 0x22c50202, 0x23c50202, 0x24c50202, + 0x25c50202, 0x26c50202, 0x27c50202, 0x28c50202, 0x29c50202, 0x2ac50202, 0x2bc50202, 0x2cc50202, + 0x2dc50202, 0x2ec50202, 0x2fc50202, 0x30c50202, 0x31c50202, 0x32c50202, 0x33c50202, 0x34c50202, + 0x35c50202, 0x36c50202, 0x37c50202, 0x38c50202, 0x39c50202, 0x3ac50202, 0x3bc50202, 0x3cc50202, + 0x3dc50202, 0x3ec50202, 0x3fc50202, 0x40c50202, 0x41c50202, 0x42c50202, 0x43c50202, 0x44c50202, + 0x45c50202, 0x46c50202, 0x47c50202, 0x48c50202, 0x49c50202, 0x4ac50202, 0x4bc50202, 0x4cc50202, + 0x4dc50202, 0x4ec50202, 0x4fc50202, 0x50c50202, 0x51c50202, 0x52c50202, 0x53c50202, 0x54c50202, + 0x55c50202, 0x56c50202, 0x57c50202, 0x58c50202, 0x59c50202, 0x5ac50202, 0x5bc50202, 0x5cc50202, + 0x5dc50202, 0x5ec50202, 0x5fc50202, 0x60c50202, 0x61c50202, 0x62c50202, 0x63c50202, 0x64c50202, + 0x65c50202, 0x66c50202, 0x67c50202, 0x68c50202, 0x69c50202, 0x6ac50202, 0x6bc50202, 0x6cc50202, + 0x6dc50202, 0x6ec50202, 0x6fc50202, 0x70c50202, 0x71c50202, 0x72c50202, 0x73c50202, 0x74c50202, + 0x75c50202, 0x76c50202, 0x77c50202, 0x78c50202, 0x79c50202, 0x7ac50202, 0x7bc50202, 0x7cc50202, + 0x7dc50202, 0x7ec50202, 0x7fc50202, 0x80c50202, 0x81c50202, 0x82c50202, 0x83c50202, 0x84c50202, + 0x85c50202, 0x86c50202, 0x87c50202, 0x88c50202, 0x89c50202, 0x8ac50202, 0x8bc50202, 0x8cc50202, + 0x8dc50202, 0x8ec50202, 0x8fc50202, 0x90c50202, 0x91c50202, 0x92c50202, 0x93c50202, 0x94c50202, + 0x95c50202, 0x96c50202, 0x97c50202, 0x98c50202, 0x99c50202, 0x9ac50202, 0x9bc50202, 0x9cc50202, + 0x9dc50202, 0x9ec50202, 0x9fc50202, 0xa0c50202, 0xa1c50202, 0xa2c50202, 0xa3c50202, 0xa4c50202, + 0xa5c50202, 0xa6c50202, 0xa7c50202, 0xa8c50202, 0xa9c50202, 0xaac50202, 0xabc50202, 0xacc50202, + 0xadc50202, 0xaec50202, 0xafc50202, 0xb0c50202, 0xb1c50202, 0xb2c50202, 0xb3c50202, 0xb4c50202, + 0xb5c50202, 0xb6c50202, 0xb7c50202, 0xb8c50202, 0xb9c50202, 0xbac50202, 0xbbc50202, 0xbcc50202, + 0xbdc50202, 0xbec50202, 0xbfc50202, 0xc0c50202, 0xc1c50202, 0xc2c50202, 0xc3c50202, 0xc4c50202, + 0xc5c50202, 0xc6c50202, 0xc7c50202, 0xc8c50202, 0xc9c50202, 0xcac50202, 0xcbc50202, 0xccc50202, + 0xcdc50202, 0xcec50202, 0xcfc50202, 0xd0c50202, 0xd1c50202, 0xd2c50202, 0xd3c50202, 0xd4c50202, + 0xd5c50202, 0xd6c50202, 0xd7c50202, 0xd8c50202, 0xd9c50202, 0xdac50202, 0xdbc50202, 0xdcc50202, + 0xddc50202, 0xdec50202, 0xdfc50202, 0xe0c50202, 0xe1c50202, 0xe2c50202, 0xe3c50202, 0xe4c50202, + 0xe5c50202, 0xe6c50202, 0xe7c50202, 0xe8c50202, 0xe9c50202, 0xeac50202, 0xebc50202, 0xecc50202, + 0xedc50202, 0xeec50202, 0xefc50202, 0xf0c50202, 0xf1c50202, 0xf2c50202, 0xf3c50202, 0xf4c50202, + 0xf5c50202, 0xf6c50202, 0xf7c50202, 0xf8c50202, 0xf9c50202, 0xfac50202, 0xfbc50202, 0xfcc50202, + 0xfdc50202, 0xfec50202, 0xffc50202, 0x02c60202, 0x03c60202, 0x04c60202, 0x05c60202, 0x06c60202, + 0x07c60202, 0x08c60202, 0x09c60202, 0x0ac60202, 0x0bc60202, 0x0cc60202, 0x0dc60202, 0x0ec60202, + 0x0fc60202, 0x10c60202, 0x11c60202, 0x12c60202, 0x13c60202, 0x14c60202, 0x15c60202, 0x16c60202, + 0x17c60202, 0x18c60202, 0x19c60202, 0x1ac60202, 0x1bc60202, 0x1cc60202, 0x1dc60202, 0x1ec60202, + 0x1fc60202, 0x20c60202, 0x21c60202, 0x22c60202, 0x23c60202, 0x24c60202, 0x25c60202, 0x26c60202, + 0x27c60202, 0x28c60202, 0x29c60202, 0x2ac60202, 0x2bc60202, 0x2cc60202, 0x2dc60202, 0x2ec60202, + 0x2fc60202, 0x30c60202, 0x31c60202, 0x32c60202, 0x33c60202, 0x34c60202, 0x35c60202, 0x36c60202, + 0x37c60202, 0x38c60202, 0x39c60202, 0x3ac60202, 0x3bc60202, 0x3cc60202, 0x3dc60202, 0x3ec60202, + 0x3fc60202, 0x40c60202, 0x41c60202, 0x42c60202, 0x43c60202, 0x44c60202, 0x45c60202, 0x46c60202, + 0x47c60202, 0x48c60202, 0x49c60202, 0x4ac60202, 0x4bc60202, 0x4cc60202, 0x4dc60202, 0x4ec60202, + 0x4fc60202, 0x50c60202, 0x51c60202, 0x52c60202, 0x53c60202, 0x54c60202, 0x55c60202, 0x56c60202, + 0x57c60202, 0x58c60202, 0x59c60202, 0x5ac60202, 0x5bc60202, 0x5cc60202, 0x5dc60202, 0x5ec60202, + 0x5fc60202, 0x60c60202, 0x61c60202, 0x62c60202, 0x63c60202, 0x64c60202, 0x65c60202, 0x66c60202, + 0x67c60202, 0x68c60202, 0x69c60202, 0x6ac60202, 0x6bc60202, 0x6cc60202, 0x6dc60202, 0x6ec60202, + 0x6fc60202, 0x70c60202, 0x71c60202, 0x72c60202, 0x73c60202, 0x74c60202, 0x75c60202, 0x76c60202, + 0x77c60202, 0x78c60202, 0x79c60202, 0x7ac60202, 0x7bc60202, 0x7cc60202, 0x7dc60202, 0x7ec60202, + 0x7fc60202, 0x80c60202, 0x81c60202, 0x82c60202, 0x83c60202, 0x84c60202, 0x85c60202, 0x86c60202, + 0x87c60202, 0x88c60202, 0x89c60202, 0x8ac60202, 0x8bc60202, 0x8cc60202, 0x8dc60202, 0x8ec60202, + 0x8fc60202, 0x90c60202, 0x91c60202, 0x92c60202, 0x93c60202, 0x94c60202, 0x95c60202, 0x96c60202, + 0x97c60202, 0x98c60202, 0x99c60202, 0x9ac60202, 0x9bc60202, 0x9cc60202, 0x9dc60202, 0x9ec60202, + 0x9fc60202, 0xa0c60202, 0xa1c60202, 0xa2c60202, 0xa3c60202, 0xa4c60202, 0xa5c60202, 0xa6c60202, + 0xa7c60202, 0xa8c60202, 0xa9c60202, 0xaac60202, 0xabc60202, 0xacc60202, 0xadc60202, 0xaec60202, + 0xafc60202, 0xb0c60202, 0xb1c60202, 0xb2c60202, 0xb3c60202, 0xb4c60202, 0xb5c60202, 0xb6c60202, + 0xb7c60202, 0xb8c60202, 0xb9c60202, 0xbac60202, 0xbbc60202, 0xbcc60202, 0xbdc60202, 0xbec60202, + 0xbfc60202, 0xc0c60202, 0xc1c60202, 0xc2c60202, 0xc3c60202, 0xc4c60202, 0xc5c60202, 0xc6c60202, + 0xc7c60202, 0xc8c60202, 0xc9c60202, 0xcac60202, 0xcbc60202, 0xccc60202, 0xcdc60202, 0xcec60202, + 0xcfc60202, 0xd0c60202, 0xd1c60202, 0xd2c60202, 0xd3c60202, 0xd4c60202, 0xd5c60202, 0xd6c60202, + 0xd7c60202, 0xd8c60202, 0xd9c60202, 0xdac60202, 0xdbc60202, 0xdcc60202, 0xddc60202, 0xdec60202, + 0xdfc60202, 0xe0c60202, 0xe1c60202, 0xe2c60202, 0xe3c60202, 0xe4c60202, 0xe5c60202, 0xe6c60202, + 0xe7c60202, 0xe8c60202, 0xe9c60202, 0xeac60202, 0xebc60202, 0xecc60202, 0xedc60202, 0xeec60202, + 0xefc60202, 0xf0c60202, 0xf1c60202, 0xf2c60202, 0xf3c60202, 0xf4c60202, 0xf5c60202, 0xf6c60202, + 0xf7c60202, 0xf8c60202, 0xf9c60202, 0xfac60202, 0x08c70302, 0x0ac70202, 0x0bc70202, 0x0cc70202, + 0x0dc70202, 0x0ec70202, 0x0fc70202, 0x10c70202, 0x11c70202, 0x12c70202, 0x13c70202, 0x14c70202, + 0x15c70202, 0x16c70202, 0x17c70202, 0x18c70202, 0x19c70202, 0x1ac70202, 0x1bc70202, 0x1cc70202, + 0x1dc70202, 0x1ec70202, 0x20c70202, 0x21c70202, 0x22c70202, 0x23c70202, 0x24c70202, 0x25c70202, + 0x26c70202, 0x27c70202, 0x28c70202, 0x29c70202, 0x2ac70202, 0x2bc70202, 0x2cc70202, 0x2dc70202, + 0x2ec70202, 0x2fc70202, 0x30c70202, 0x31c70202, 0x32c70202, 0x33c70202, 0x34c70202, 0x35c70202, + 0x36c70202, 0x37c70202, 0x38c70202, 0x39c70202, 0x3ac70202, 0x3bc70202, 0x3cc70202, 0x3dc70202, + 0x3ec70202, 0x3fc70202, 0x40c70202, 0x41c70202, 0x42c70202, 0x43c70202, 0x44c70202, 0x45c70202, + 0x46c70202, 0x47c70202, 0x48c70202, 0x49c70202, 0x4ac70202, 0x4bc70202, 0x4cc70202, 0x4dc70202, + 0x4ec70202, 0x4fc70202, 0x50c70202, 0x51c70202, 0x52c70202, 0x53c70202, 0x54c70202, 0x55c70202, + 0x56c70202, 0x57c70202, 0x58c70202, 0x59c70202, 0x5ac70202, 0x5bc70202, 0x5cc70202, 0x5dc70202, + 0x5ec70202, 0x5fc70202, 0x60c70202, 0x61c70202, 0x62c70202, 0x63c70202, 0x64c70202, 0x65c70202, + 0x66c70202, 0x67c70202, 0x68c70202, 0x69c70202, 0x6ac70202, 0x6bc70202, 0x6cc70202, 0x6dc70202, + 0x6ec70202, 0x6fc70202, 0x70c70202, 0x71c70202, 0x72c70202, 0x73c70202, 0x74c70202, 0x75c70202, + 0x76c70202, 0x77c70202, 0x78c70202, 0x79c70202, 0x7ac70202, 0x7bc70202, 0x82c70202, 0x83c70202, + 0x84c70202, 0x85c70202, 0x86c70202, 0x87c70202, 0x88c70202, 0x89c70202, 0x8ac70202, 0x8bc70202, + 0x8cc70202, 0x8dc70202, 0x8ec70202, 0x8fc70202, 0x90c70202, 0x91c70202, 0x92c70202, 0x93c70202, + 0x94c70202, 0x95c70202, 0x96c70202, 0x97c70202, 0x98c70202, 0x99c70202, 0x9ac70202, 0x9bc70202, + 0x9cc70202, 0x9dc70202, 0x9ec70202, 0x9fc70202, 0xa0c70202, 0xa1c70202, 0xa2c70202, 0xa3c70202, + 0xa4c70202, 0xa5c70202, 0xa6c70202, 0xa7c70202, 0xa8c70202, 0xa9c70202, 0xaac70202, 0xabc70202, + 0xacc70202, 0xadc70202, 0xaec70202, 0xafc70202, 0xb0c70202, 0xb1c70202, 0xb2c70202, 0xb3c70202, + 0xb4c70202, 0xb5c70202, 0xb6c70202, 0xb7c70202, 0xb8c70202, 0xb9c70202, 0xbac70202, 0xbbc70202, + 0xbcc70202, 0xbdc70202, 0xbec70202, 0xbfc70202, 0xc0c70202, 0xc1c70202, 0xc2c70202, 0xc3c70202, + 0xc4c70202, 0xc5c70202, 0xc6c70202, 0xc7c70202, 0xc8c70202, 0xc9c70202, 0xcac70202, 0xcbc70202, + 0xccc70202, 0xcdc70202, 0xcec70202, 0xcfc70202, 0xd0c70202, 0xd1c70202, 0xd2c70202, 0xd3c70202, + 0xd4c70202, 0xd5c70202, 0xd6c70202, 0xd7c70202, 0xd8c70202, 0xd9c70202, 0xdac70202, 0xdbc70202, + 0xdcc70202, 0xddc70202, 0xdec70202, 0xdfc70202, 0xe0c70202, 0xe1c70202, 0xe2c70202, 0xe3c70202, + 0xe4c70202, 0xe5c70202, 0xe6c70202, 0xe7c70202, 0xe8c70202, 0xe9c70202, 0xeac70202, 0xebc70202, + 0xecc70202, 0xedc70202, 0xeec70202, 0xefc70202, 0xf0c70202, 0xf1c70202, 0xf2c70202, 0xf3c70202, + 0xf4c70202, 0xf5c70202, 0xf6c70202, 0xf7c70202, 0xf8c70202, 0xf9c70202, 0xfac70202, 0xfbc70202, + 0xfcc70202, 0xfdc70202, 0xfec70202, 0xffc70202, 0x02c80202, 0x03c80202, 0x04c80202, 0x05c80202, + 0x06c80202, 0x07c80202, 0x08c80202, 0x09c80202, 0x0ac80202, 0x0bc80202, 0x0cc80202, 0x0dc80202, + 0x0ec80202, 0x0fc80202, 0x10c80202, 0x11c80202, 0x12c80202, 0x13c80202, 0x14c80202, 0x15c80202, + 0x16c80202, 0x17c80202, 0x18c80202, 0x19c80202, 0x1ac80202, 0x1bc80202, 0x1cc80202, 0x1dc80202, + 0x1ec80202, 0x1fc80202, 0x20c80202, 0x21c80202, 0x22c80202, 0x23c80202, 0x24c80202, 0x25c80202, + 0x26c80202, 0x27c80202, 0x28c80202, 0x29c80202, 0x2ac80202, 0x2bc80202, 0x2cc80202, 0x2dc80202, + 0x2ec80202, 0x2fc80202, 0x30c80202, 0x31c80202, 0x32c80202, 0x33c80202, 0x34c80202, 0x35c80202, + 0x36c80202, 0x37c80202, 0x38c80202, 0x39c80202, 0x3ac80202, 0x3bc80202, 0x3cc80202, 0x3dc80202, + 0x3ec80202, 0x3fc80202, 0x40c80202, 0x41c80202, 0x42c80202, 0x43c80202, 0x44c80202, 0x45c80202, + 0x46c80202, 0x47c80202, 0x48c80202, 0x49c80202, 0x4ac80202, 0x4bc80202, 0x4cc80202, 0x4dc80202, + 0x4ec80202, 0x4fc80202, 0x50c80202, 0x51c80202, 0x52c80202, 0x53c80202, 0x54c80202, 0x55c80202, + 0x56c80202, 0x57c80202, 0x58c80202, 0x59c80202, 0x5ac80202, 0x5bc80202, 0x5cc80202, 0x5dc80202, + 0x5ec80202, 0x5fc80202, 0x60c80202, 0x61c80202, 0x62c80202, 0x63c80202, 0x64c80202, 0x65c80202, + 0x66c80202, 0x67c80202, 0x68c80202, 0x69c80202, 0x6ac80202, 0x6bc80202, 0x6cc80202, 0x6dc80202, + 0x6ec80202, 0x6fc80202, 0x70c80202, 0x71c80202, 0x72c80202, 0x73c80202, 0x74c80202, 0x75c80202, + 0x76c80202, 0x77c80202, 0x78c80202, 0x79c80202, 0x7ac80202, 0x7bc80202, 0x7cc80202, 0x7dc80202, + 0x7ec80202, 0x7fc80202, 0x80c80202, 0x81c80202, 0x82c80202, 0x83c80202, 0x84c80202, 0x85c80202, + 0x86c80202, 0x87c80202, 0x88c80202, 0x89c80202, 0x8ac80202, 0x8bc80202, 0x8cc80202, 0x8dc80202, + 0x8ec80202, 0x8fc80202, 0x90c80202, 0x91c80202, 0x92c80202, 0x93c80202, 0x94c80202, 0x95c80202, + 0x96c80202, 0x97c80202, 0x98c80202, 0x99c80202, 0x9ac80202, 0x9bc80202, 0x9cc80202, 0x9dc80202, + 0x9ec80202, 0x9fc80202, 0xa0c80202, 0xa1c80202, 0xa2c80202, 0xa3c80202, 0xa4c80202, 0xa5c80202, + 0xa6c80202, 0xa7c80202, 0xa8c80202, 0xa9c80202, 0xaac80202, 0xabc80202, 0xacc80202, 0xadc80202, + 0xaec80202, 0xafc80202, 0xb0c80202, 0xb1c80202, 0xb2c80202, 0xb3c80202, 0xb4c80202, 0xb5c80202, + 0xb6c80202, 0xb7c80202, 0xb8c80202, 0xb9c80202, 0xbac80202, 0xbbc80202, 0xbcc80202, 0xbdc80202, + 0xbec80202, 0xbfc80202, 0xc0c80202, 0xc1c80202, 0xc2c80202, 0xc3c80202, 0xc4c80202, 0xc5c80202, + 0xc6c80202, 0xc7c80202, 0xc8c80202, 0xc9c80202, 0xcac80202, 0xcbc80202, 0xccc80202, 0xcdc80202, + 0xcec80202, 0xcfc80202, 0xd0c80202, 0xd1c80202, 0xd2c80202, 0xd3c80202, 0xd4c80202, 0xd5c80202, + 0xd6c80202, 0xd7c80202, 0xd8c80202, 0xd9c80202, 0xdac80202, 0xdbc80202, 0xdcc80202, 0xddc80202, + 0xdec80202, 0xdfc80202, 0xe0c80202, 0xe1c80202, 0xe2c80202, 0xe3c80202, 0xe4c80202, 0xe5c80202, + 0xe6c80202, 0xe7c80202, 0xe8c80202, 0xe9c80202, 0xeac80202, 0xebc80202, 0xecc80202, 0xedc80202, + 0xeec80202, 0xefc80202, 0xf0c80202, 0xf1c80202, 0xf2c80202, 0xf3c80202, 0xf4c80202, 0xf5c80202, + 0xf6c80202, 0xf7c80202, 0xf8c80202, 0xf9c80202, 0xfac80202, 0xfbc80202, 0xfcc80202, 0xfdc80202, + 0xfec80202, 0xffc80202, 0x02c90202, 0x03c90202, 0x04c90202, 0x05c90202, 0x06c90202, 0x07c90202, + 0x08c90202, 0x09c90202, 0x0ac90202, 0x0bc90202, 0x0cc90202, 0x0dc90202, 0x0ec90202, 0x0fc90202, + 0x10c90202, 0x11c90202, 0x12c90202, 0x13c90202, 0x14c90202, 0x15c90202, 0x16c90202, 0x17c90202, + 0x18c90202, 0x19c90202, 0x1ac90202, 0x1bc90202, 0x1cc90202, 0x1dc90202, 0x1ec90202, 0x1fc90202, + 0x20c90202, 0x21c90202, 0x22c90202, 0x23c90202, 0x24c90202, 0x25c90202, 0x26c90202, 0x27c90202, + 0x28c90202, 0x29c90202, 0x2ac90202, 0x2bc90202, 0x2cc90202, 0x2dc90202, 0x2ec90202, 0x2fc90202, + 0x30c90202, 0x31c90202, 0x32c90202, 0x33c90202, 0x34c90202, 0x35c90202, 0x36c90202, 0x37c90202, + 0x38c90202, 0x39c90202, 0x3ac90202, 0x3bc90202, 0x3cc90202, 0x3dc90202, 0x3ec90202, 0x3fc90202, + 0x40c90202, 0x41c90202, 0x42c90202, 0x43c90202, 0x44c90202, 0x45c90202, 0x46c90202, 0x47c90202, + 0x48c90202, 0x49c90202, 0x4ac90202, 0x4bc90202, 0x4cc90202, 0x4dc90202, 0x4ec90202, 0x4fc90202, + 0x50c90202, 0x51c90202, 0x52c90202, 0x53c90202, 0x54c90202, 0x55c90202, 0x56c90202, 0x57c90202, + 0x58c90202, 0x59c90202, 0x5ac90202, 0x5bc90202, 0x5cc90202, 0x5dc90202, 0x5ec90202, 0x5fc90202, + 0x62c90202, 0x63c90202, 0x64c90202, 0x65c90202, 0x66c90202, 0x67c90202, 0x68c90202, 0x69c90202, + 0x6ac90202, 0x6bc90202, 0x6cc90202, 0x6dc90202, 0x6ec90202, 0x6fc90202, 0x70c90202, 0x71c90202, + 0x72c90202, 0x73c90202, 0x74c90202, 0x75c90202, 0x76c90202, 0x77c90202, 0x78c90202, 0x79c90202, + 0x7ac90202, 0x7bc90202, 0x7cc90202, 0x7dc90202, 0x7ec90202, 0x7fc90202, 0x80c90202, 0x81c90202, + 0x82c90202, 0x83c90202, 0x84c90202, 0x85c90202, 0x86c90202, 0x87c90202, 0x88c90202, 0x89c90202, + 0x8ac90202, 0x8bc90202, 0x8cc90202, 0x8dc90202, 0x8ec90202, 0x8fc90202, 0x90c90202, 0x91c90202, + 0x92c90202, 0x93c90202, 0x94c90202, 0x95c90202, 0x96c90202, 0x97c90202, 0x98c90202, 0x99c90202, + 0x9ac90202, 0x9bc90202, 0x9cc90202, 0x9dc90202, 0x9ec90202, 0x9fc90202, 0xa0c90202, 0xa1c90202, + 0xa2c90202, 0xa3c90202, 0xa4c90202, 0xa5c90202, 0xa6c90202, 0xa7c90202, 0xa8c90202, 0xa9c90202, + 0xaac90202, 0xabc90202, 0xacc90202, 0xadc90202, 0xaec90202, 0xafc90202, 0xb0c90202, 0xb1c90202, + 0xb2c90202, 0xb3c90202, 0xb4c90202, 0xb5c90202, 0xb6c90202, 0xb7c90202, 0xb8c90202, 0xb9c90202, + 0xbac90202, 0xbbc90202, 0xbcc90202, 0xbdc90202, 0xbec90202, 0xbfc90202, 0xc0c90202, 0xc1c90202, + 0xc2c90202, 0xc3c90202, 0xc4c90202, 0xc5c90202, 0xc6c90202, 0xc7c90202, 0xc8c90202, 0xc9c90202, + 0xcac90202, 0xcbc90202, 0xccc90202, 0xcdc90202, 0xcec90202, 0xcfc90202, 0xd0c90202, 0xd1c90202, + 0xd2c90202, 0xd3c90202, 0xd4c90202, 0xd5c90202, 0xd6c90202, 0xd7c90202, 0xd8c90202, 0xd9c90202, + 0xdac90202, 0xdbc90202, 0xdcc90202, 0xddc90202, 0xdec90202, 0xdfc90202, 0xe0c90202, 0xe1c90202, + 0xe2c90202, 0xe3c90202, 0xe4c90202, 0xe5c90202, 0xe6c90202, 0xe7c90202, 0xe8c90202, 0xe9c90202, + 0xeac90202, 0xebc90202, 0xecc90202, 0xedc90202, 0xeec90202, 0xefc90202, 0xf0c90202, 0xf1c90202, + 0xf2c90202, 0xf3c90202, 0xf4c90202, 0xf5c90202, 0xf6c90202, 0xf7c90202, 0xf8c90202, 0xf9c90202, + 0xfac90202, 0xfbc90202, 0xfcc90202, 0xfdc90202, 0xfec90202, 0xffc90202, 0x02ca0202, 0x03ca0202, + 0x04ca0202, 0x05ca0202, 0x06ca0202, 0x07ca0202, 0x08ca0202, 0x09ca0202, 0x0aca0202, 0x0bca0202, + 0x0cca0202, 0x0dca0202, 0x0eca0202, 0x0fca0202, 0x10ca0202, 0x11ca0202, 0x12ca0202, 0x13ca0202, + 0x14ca0202, 0x15ca0202, 0x16ca0202, 0x17ca0202, 0x18ca0202, 0x19ca0202, 0x1aca0202, 0x1bca0202, + 0x1cca0202, 0x1dca0202, 0x1eca0202, 0x1fca0202, 0x20ca0202, 0x21ca0202, 0x22ca0202, 0x23ca0202, + 0x24ca0202, 0x25ca0202, 0x26ca0202, 0x27ca0202, 0x28ca0202, 0x29ca0202, 0x2aca0202, 0x2bca0202, + 0x2cca0202, 0x2dca0202, 0x2eca0202, 0x2fca0202, 0x30ca0202, 0x31ca0202, 0x32ca0202, 0x33ca0202, + 0x34ca0202, 0x35ca0202, 0x36ca0202, 0x37ca0202, 0x38ca0202, 0x39ca0202, 0x3aca0202, 0x3bca0202, + 0x3cca0202, 0x3dca0202, 0x3eca0202, 0x3fca0202, 0x40ca0202, 0x41ca0202, 0x42ca0202, 0x43ca0202, + 0x44ca0202, 0x45ca0202, 0x46ca0202, 0x47ca0202, 0x48ca0202, 0x49ca0202, 0x4aca0202, 0x4bca0202, + 0x4cca0202, 0x4dca0202, 0x4eca0202, 0x4fca0202, 0x50ca0202, 0x51ca0202, 0x52ca0202, 0x53ca0202, + 0x54ca0202, 0x55ca0202, 0x56ca0202, 0x57ca0202, 0x58ca0202, 0x59ca0202, 0x5aca0202, 0x5bca0202, + 0x5cca0202, 0x5dca0202, 0x5eca0202, 0x5fca0202, 0x60ca0202, 0x61ca0202, 0x62ca0202, 0x63ca0202, + 0x64ca0202, 0x65ca0202, 0x66ca0202, 0x67ca0202, 0x68ca0202, 0x69ca0202, 0x6aca0202, 0x6bca0202, + 0x6cca0202, 0x6dca0202, 0x6eca0202, 0x6fca0202, 0x70ca0202, 0x71ca0202, 0x72ca0202, 0x73ca0202, + 0x74ca0202, 0x75ca0202, 0x76ca0202, 0x77ca0202, 0x78ca0202, 0x79ca0202, 0x7aca0202, 0x7bca0202, + 0x7cca0202, 0x7dca0202, 0x7eca0202, 0x7fca0202, 0x80ca0202, 0x81ca0202, 0x82ca0202, 0x83ca0202, + 0x84ca0202, 0x85ca0202, 0x86ca0202, 0x87ca0202, 0x88ca0202, 0x89ca0202, 0x8aca0202, 0x8bca0202, + 0x8cca0202, 0x8dca0202, 0x8eca0202, 0x8fca0202, 0x90ca0202, 0x91ca0202, 0x92ca0202, 0x93ca0202, + 0x94ca0202, 0x95ca0202, 0x96ca0202, 0x97ca0202, 0x98ca0202, 0x99ca0202, 0x9aca0202, 0x9bca0202, + 0x9cca0202, 0x9dca0202, 0x9eca0202, 0x9fca0202, 0xa0ca0202, 0xa1ca0202, 0xa2ca0202, 0xa3ca0202, + 0xa4ca0202, 0xa5ca0202, 0xa6ca0202, 0xa7ca0202, 0xa8ca0202, 0xa9ca0202, 0xaaca0202, 0xabca0202, + 0xacca0202, 0xadca0202, 0xaeca0202, 0xafca0202, 0xb0ca0202, 0xb1ca0202, 0xb2ca0202, 0xb3ca0202, + 0xb4ca0202, 0xb5ca0202, 0xb6ca0202, 0xb7ca0202, 0xb8ca0202, 0xb9ca0202, 0xbaca0202, 0xbbca0202, + 0xbcca0202, 0xbdca0202, 0xbeca0202, 0xbfca0202, 0xc0ca0202, 0xc1ca0202, 0xc2ca0202, 0xc3ca0202, + 0xc4ca0202, 0xc5ca0202, 0xc6ca0202, 0xc7ca0202, 0xc8ca0202, 0xc9ca0202, 0xcaca0202, 0xcbca0202, + 0xccca0202, 0xcdca0202, 0xceca0202, 0xcfca0202, 0xd0ca0202, 0xd1ca0202, 0xd2ca0202, 0xd3ca0202, + 0xd4ca0202, 0xd5ca0202, 0xd6ca0202, 0xd7ca0202, 0xd8ca0202, 0xd9ca0202, 0xdaca0202, 0xdbca0202, + 0xdcca0202, 0xddca0202, 0xdeca0202, 0xdfca0202, 0xe0ca0202, 0xe1ca0202, 0xe2ca0202, 0xe3ca0202, + 0xe4ca0202, 0xe5ca0202, 0xe6ca0202, 0xe7ca0202, 0xe8ca0202, 0xe9ca0202, 0xeaca0202, 0xebca0202, + 0xecca0202, 0xedca0202, 0xeeca0202, 0xefca0202, 0xf0ca0202, 0xf1ca0202, 0xf2ca0202, 0xf3ca0202, + 0xf4ca0202, 0xf5ca0202, 0xf6ca0202, 0xf7ca0202, 0xf8ca0202, 0xf9ca0202, 0xfaca0202, 0xfbca0202, + 0xfcca0202, 0xfdca0202, 0xfeca0202, 0xffca0202, 0x02cb0202, 0x03cb0202, 0x04cb0202, 0x05cb0202, + 0x06cb0202, 0x07cb0202, 0x08cb0202, 0x09cb0202, 0x0acb0202, 0x0bcb0202, 0x0ccb0202, 0x0dcb0202, + 0x0ecb0202, 0x0fcb0202, 0x10cb0202, 0x11cb0202, 0x12cb0202, 0x13cb0202, 0x14cb0202, 0x15cb0202, + 0x16cb0202, 0x17cb0202, 0x18cb0202, 0x19cb0202, 0x1acb0202, 0x1bcb0202, 0x1ccb0202, 0x1dcb0202, + 0x1ecb0202, 0x1fcb0202, 0x20cb0202, 0x21cb0202, 0x22cb0202, 0x23cb0202, 0x24cb0202, 0x25cb0202, + 0x26cb0202, 0x27cb0202, 0x28cb0202, 0x29cb0202, 0x2acb0202, 0x2bcb0202, 0x2ccb0202, 0x2dcb0202, + 0x2ecb0202, 0x2fcb0202, 0x30cb0202, 0x31cb0202, 0x32cb0202, 0x33cb0202, 0x34cb0202, 0x35cb0202, + 0x36cb0202, 0x37cb0202, 0x38cb0202, 0x39cb0202, 0x3acb0202, 0x3bcb0202, 0x3ccb0202, 0x3dcb0202, + 0x3ecb0202, 0x3fcb0202, 0x40cb0202, 0x41cb0202, 0x42cb0202, 0x43cb0202, 0x44cb0202, 0x45cb0202, + 0x46cb0202, 0x47cb0202, 0x48cb0202, 0x49cb0202, 0x4acb0202, 0x4bcb0202, 0x4ccb0202, 0x4dcb0202, + 0x4ecb0202, 0x4fcb0202, 0x50cb0202, 0x51cb0202, 0x52cb0202, 0x53cb0202, 0x54cb0202, 0x55cb0202, + 0x56cb0202, 0x57cb0202, 0x58cb0202, 0x59cb0202, 0x5acb0202, 0x5bcb0202, 0x5ccb0202, 0x5dcb0202, + 0x5ecb0202, 0x5fcb0202, 0x60cb0202, 0x61cb0202, 0x62cb0202, 0x63cb0202, 0x64cb0202, 0x65cb0202, + 0x66cb0202, 0x67cb0202, 0x68cb0202, 0x69cb0202, 0x6acb0202, 0x6bcb0202, 0x6ccb0202, 0x6dcb0202, + 0x6ecb0202, 0x6fcb0202, 0x70cb0202, 0x71cb0202, 0x72cb0202, 0x73cb0202, 0x74cb0202, 0x75cb0202, + 0x76cb0202, 0x77cb0202, 0x78cb0202, 0x79cb0202, 0x7acb0202, 0x7bcb0202, 0x7ccb0202, 0x7dcb0202, + 0x7ecb0202, 0x7fcb0202, 0x80cb0202, 0x81cb0202, 0x82cb0202, 0x83cb0202, 0x84cb0202, 0x85cb0202, + 0x86cb0202, 0x87cb0202, 0x88cb0202, 0x89cb0202, 0x8acb0202, 0x8bcb0202, 0x8ccb0202, 0x8dcb0202, + 0x8ecb0202, 0x8fcb0202, 0x90cb0202, 0x91cb0202, 0x92cb0202, 0x93cb0202, 0x94cb0202, 0x95cb0202, + 0x96cb0202, 0x97cb0202, 0x98cb0202, 0x99cb0202, 0x9acb0202, 0x9bcb0202, 0x9ccb0202, 0x9dcb0202, + 0x9ecb0202, 0x9fcb0202, 0xa0cb0202, 0xa1cb0202, 0xa2cb0202, 0xa3cb0202, 0xa4cb0202, 0xa5cb0202, + 0xa6cb0202, 0xa7cb0202, 0xa8cb0202, 0xa9cb0202, 0xaacb0202, 0xabcb0202, 0xaccb0202, 0xadcb0202, + 0xaecb0202, 0xafcb0202, 0xb0cb0202, 0xb1cb0202, 0xb4cb0202, 0xb5cb0202, 0xb6cb0202, 0xb7cb0202, + 0xb8cb0202, 0xb9cb0202, 0xbacb0202, 0xbbcb0202, 0xbccb0202, 0xbdcb0202, 0xbecb0202, 0xbfcb0202, + 0xc0cb0202, 0xc1cb0202, 0xc2cb0202, 0xc3cb0202, 0xc4cb0202, 0xc5cb0202, 0xc6cb0202, 0xc7cb0202, + 0xc8cb0202, 0xc9cb0202, 0xcacb0202, 0xcbcb0202, 0xcccb0202, 0xcdcb0202, 0xcecb0202, 0xcfcb0202, + 0xd0cb0202, 0xd1cb0202, 0xd2cb0202, 0xd3cb0202, 0xd4cb0202, 0xd5cb0202, 0xd6cb0202, 0xd7cb0202, + 0xd8cb0202, 0xd9cb0202, 0xdacb0202, 0xdbcb0202, 0xdccb0202, 0xddcb0202, 0xdecb0202, 0xdfcb0202, + 0xe0cb0202, 0xe1cb0202, 0xe2cb0202, 0xe3cb0202, 0xe4cb0202, 0xe5cb0202, 0xe6cb0202, 0xe7cb0202, + 0xe8cb0202, 0xe9cb0202, 0xeacb0202, 0xebcb0202, 0xeccb0202, 0xedcb0202, 0xeecb0202, 0xefcb0202, + 0xf0cb0202, 0xf1cb0202, 0xf2cb0202, 0xf3cb0202, 0xf4cb0202, 0xf5cb0202, 0xf6cb0202, 0xf7cb0202, + 0xf8cb0202, 0xf9cb0202, 0xfacb0202, 0xfbcb0202, 0xfccb0202, 0xfdcb0202, 0xfecb0202, 0xffcb0202, + 0x02cc0202, 0x03cc0202, 0x04cc0202, 0x05cc0202, 0x06cc0202, 0x07cc0202, 0x08cc0202, 0x09cc0202, + 0x0acc0202, 0x0bcc0202, 0x0ccc0202, 0x0dcc0202, 0x0ecc0202, 0x0fcc0202, 0x10cc0202, 0x11cc0202, + 0x12cc0202, 0x13cc0202, 0x14cc0202, 0x15cc0202, 0x16cc0202, 0x17cc0202, 0x18cc0202, 0x19cc0202, + 0x1acc0202, 0x1bcc0202, 0x1ccc0202, 0x1dcc0202, 0x1ecc0202, 0x1fcc0202, 0x20cc0202, 0x21cc0202, + 0x22cc0202, 0x23cc0202, 0x24cc0202, 0x25cc0202, 0x26cc0202, 0x27cc0202, 0x28cc0202, 0x29cc0202, + 0x2acc0202, 0x2bcc0202, 0x2ccc0202, 0x2dcc0202, 0x2ecc0202, 0x2fcc0202, 0x30cc0202, 0x31cc0202, + 0x32cc0202, 0x33cc0202, 0x34cc0202, 0x35cc0202, 0x36cc0202, 0x37cc0202, 0x38cc0202, 0x39cc0202, + 0x3acc0202, 0x3bcc0202, 0x3ccc0202, 0x3dcc0202, 0x3ecc0202, 0x3fcc0202, 0x40cc0202, 0x41cc0202, + 0x42cc0202, 0x43cc0202, 0x44cc0202, 0x45cc0202, 0x46cc0202, 0x47cc0202, 0x48cc0202, 0x49cc0202, + 0x4acc0202, 0x4bcc0202, 0x4ccc0202, 0x4dcc0202, 0x4ecc0202, 0x4fcc0202, 0x50cc0202, 0x51cc0202, + 0x52cc0202, 0x53cc0202, 0x54cc0202, 0x55cc0202, 0x56cc0202, 0x57cc0202, 0x58cc0202, 0x59cc0202, + 0x5acc0202, 0x5bcc0202, 0x5ccc0202, 0x5dcc0202, 0x5ecc0202, 0x5fcc0202, 0x60cc0202, 0x61cc0202, + 0x62cc0202, 0x63cc0202, 0x64cc0202, 0x65cc0202, 0x66cc0202, 0x67cc0202, 0x68cc0202, 0x69cc0202, + 0x6acc0202, 0x6bcc0202, 0x6ccc0202, 0x6dcc0202, 0x6ecc0202, 0x6fcc0202, 0x70cc0202, 0x71cc0202, + 0x72cc0202, 0x73cc0202, 0x74cc0202, 0x75cc0202, 0x76cc0202, 0x77cc0202, 0x78cc0202, 0x79cc0202, + 0x7acc0202, 0x7bcc0202, 0x7ccc0202, 0x7dcc0202, 0x7ecc0202, 0x7fcc0202, 0x80cc0202, 0x81cc0202, + 0x82cc0202, 0x83cc0202, 0x84cc0202, 0x85cc0202, 0x86cc0202, 0x87cc0202, 0x88cc0202, 0x89cc0202, + 0x8acc0202, 0x8bcc0202, 0x8ccc0202, 0x8dcc0202, 0x8ecc0202, 0x8fcc0202, 0x90cc0202, 0x91cc0202, + 0x92cc0202, 0x93cc0202, 0x94cc0202, 0x95cc0202, 0x96cc0202, 0x97cc0202, 0x98cc0202, 0x99cc0202, + 0x9acc0202, 0x9bcc0202, 0x9ccc0202, 0x9dcc0202, 0x9ecc0202, 0x9fcc0202, 0xa0cc0202, 0xa1cc0202, + 0xa2cc0202, 0xa3cc0202, 0xa4cc0202, 0xa5cc0202, 0xa6cc0202, 0xa7cc0202, 0xa8cc0202, 0xa9cc0202, + 0xaacc0202, 0xabcc0202, 0xaccc0202, 0xadcc0202, 0xaecc0202, 0xafcc0202, 0xb0cc0202, 0xb1cc0202, + 0xb2cc0202, 0xb3cc0202, 0xb4cc0202, 0xb5cc0202, 0xb6cc0202, 0xb7cc0202, 0xb8cc0202, 0xb9cc0202, + 0xbacc0202, 0xbbcc0202, 0xbccc0202, 0xbdcc0202, 0xbecc0202, 0xbfcc0202, 0xc0cc0202, 0xc1cc0202, + 0xc2cc0202, 0xc3cc0202, 0xc4cc0202, 0xc5cc0202, 0xc6cc0202, 0xc7cc0202, 0xc8cc0202, 0xc9cc0202, + 0xcacc0202, 0xcbcc0202, 0xcccc0202, 0xcdcc0202, 0xcecc0202, 0xcfcc0202, 0xd0cc0202, 0xd1cc0202, + 0xd2cc0202, 0xd3cc0202, 0xd4cc0202, 0xd5cc0202, 0xd6cc0202, 0xd7cc0202, 0xd8cc0202, 0xd9cc0202, + 0xdacc0202, 0xdbcc0202, 0xdccc0202, 0xddcc0202, 0xdecc0202, 0xdfcc0202, 0xe0cc0202, 0xe1cc0202, + 0xe2cc0202, 0xe3cc0202, 0xe4cc0202, 0xe5cc0202, 0xe6cc0202, 0xe7cc0202, 0xe8cc0202, 0xe9cc0202, + 0xeacc0202, 0xebcc0202, 0xeccc0202, 0xedcc0202, 0xeecc0202, 0xefcc0202, 0xf0cc0202, 0xf1cc0202, + 0xf2cc0202, 0xf3cc0202, 0xf4cc0202, 0xf5cc0202, 0xf6cc0202, 0xf7cc0202, 0xf8cc0202, 0xf9cc0202, + 0xfacc0202, 0xfbcc0202, 0xfccc0202, 0xfdcc0202, 0xfecc0202, 0xffcc0202, 0x02cd0202, 0x03cd0202, + 0x04cd0202, 0x05cd0202, 0x06cd0202, 0x07cd0202, 0x08cd0202, 0x09cd0202, 0x0acd0202, 0x0bcd0202, + 0x0ccd0202, 0x0dcd0202, 0x0ecd0202, 0x0fcd0202, 0x10cd0202, 0x11cd0202, 0x12cd0202, 0x13cd0202, + 0x14cd0202, 0x15cd0202, 0x16cd0202, 0x17cd0202, 0x18cd0202, 0x19cd0202, 0x1acd0202, 0x1bcd0202, + 0x1ccd0202, 0x1dcd0202, 0x1ecd0202, 0x1fcd0202, 0x20cd0202, 0x21cd0202, 0x22cd0202, 0x23cd0202, + 0x24cd0202, 0x25cd0202, 0x26cd0202, 0x27cd0202, 0x28cd0202, 0x29cd0202, 0x2acd0202, 0x2bcd0202, + 0x2ccd0202, 0x2dcd0202, 0x2ecd0202, 0x2fcd0202, 0x30cd0202, 0x31cd0202, 0x32cd0202, 0x33cd0202, + 0x34cd0202, 0x35cd0202, 0x36cd0202, 0x37cd0202, 0x38cd0202, 0x39cd0202, 0x3acd0202, 0x3bcd0202, + 0x3ccd0202, 0x3dcd0202, 0x3ecd0202, 0x3fcd0202, 0x40cd0202, 0x41cd0202, 0x42cd0202, 0x43cd0202, + 0x44cd0202, 0x45cd0202, 0x46cd0202, 0x47cd0202, 0x48cd0202, 0x49cd0202, 0x4acd0202, 0x4bcd0202, + 0x4ccd0202, 0x4dcd0202, 0x4ecd0202, 0x4fcd0202, 0x50cd0202, 0x51cd0202, 0x52cd0202, 0x53cd0202, + 0x54cd0202, 0x55cd0202, 0x56cd0202, 0x57cd0202, 0x58cd0202, 0x59cd0202, 0x5acd0202, 0x5bcd0202, + 0x5ccd0202, 0x5dcd0202, 0x5ecd0202, 0x5fcd0202, 0x60cd0202, 0x61cd0202, 0x62cd0202, 0x63cd0202, + 0x64cd0202, 0x65cd0202, 0x66cd0202, 0x67cd0202, 0x68cd0202, 0x69cd0202, 0x6acd0202, 0x6bcd0202, + 0x6ccd0202, 0x6dcd0202, 0x6ecd0202, 0x6fcd0202, 0x70cd0202, 0x71cd0202, 0x72cd0202, 0x73cd0202, + 0x74cd0202, 0x75cd0202, 0x76cd0202, 0x77cd0202, 0x78cd0202, 0x79cd0202, 0x7acd0202, 0x7bcd0202, + 0x7ccd0202, 0x7dcd0202, 0x7ecd0202, 0x7fcd0202, 0x80cd0202, 0x81cd0202, 0x82cd0202, 0x83cd0202, + 0x84cd0202, 0x85cd0202, 0x86cd0202, 0x87cd0202, 0x88cd0202, 0x89cd0202, 0x8acd0202, 0x8bcd0202, + 0x8ccd0202, 0x8dcd0202, 0x8ecd0202, 0x8fcd0202, 0x90cd0202, 0x91cd0202, 0x92cd0202, 0x93cd0202, + 0x94cd0202, 0x95cd0202, 0x96cd0202, 0x97cd0202, 0x98cd0202, 0x99cd0202, 0x9acd0202, 0x9bcd0202, + 0x9ccd0202, 0x9dcd0202, 0x9ecd0202, 0x9fcd0202, 0xa0cd0202, 0xa1cd0202, 0xa2cd0202, 0xa3cd0202, + 0xa4cd0202, 0xa5cd0202, 0xa6cd0202, 0xa7cd0202, 0xa8cd0202, 0xa9cd0202, 0xaacd0202, 0xabcd0202, + 0xaccd0202, 0xadcd0202, 0xaecd0202, 0xafcd0202, 0xb0cd0202, 0xb1cd0202, 0xb2cd0202, 0xb3cd0202, + 0xb4cd0202, 0xb5cd0202, 0xb6cd0202, 0xb7cd0202, 0xb8cd0202, 0xb9cd0202, 0xbacd0202, 0xbbcd0202, + 0xbccd0202, 0xbdcd0202, 0xbecd0202, 0xbfcd0202, 0xc0cd0202, 0xc1cd0202, 0xc2cd0202, 0xc3cd0202, + 0xc4cd0202, 0xc5cd0202, 0xc6cd0202, 0xc7cd0202, 0xc8cd0202, 0xc9cd0202, 0xcacd0202, 0xcbcd0202, + 0xcccd0202, 0xcdcd0202, 0xcecd0202, 0xcfcd0202, 0xd0cd0202, 0xd1cd0202, 0xd2cd0202, 0xd3cd0202, + 0xd4cd0202, 0xd5cd0202, 0xd6cd0202, 0xd7cd0202, 0xd8cd0202, 0xd9cd0202, 0xdacd0202, 0xdbcd0202, + 0xdccd0202, 0xddcd0202, 0xdecd0202, 0xdfcd0202, 0xe0cd0202, 0xe1cd0202, 0xe2cd0202, 0xe3cd0202, + 0xe4cd0202, 0xe5cd0202, 0xe6cd0202, 0xe7cd0202, 0xe8cd0202, 0xe9cd0202, 0xeacd0202, 0xebcd0202, + 0xeccd0202, 0xedcd0202, 0xeecd0202, 0xefcd0202, 0xf0cd0202, 0xf1cd0202, 0xf2cd0202, 0xf3cd0202, + 0xf4cd0202, 0xf5cd0202, 0xf6cd0202, 0xf7cd0202, 0xf8cd0202, 0xf9cd0202, 0xfacd0202, 0xfbcd0202, + 0xfccd0202, 0xfdcd0202, 0xfecd0202, 0xffcd0202, 0x02ce0202, 0x03ce0202, 0x04ce0202, 0x05ce0202, + 0x1dce0202, 0x1ece0202, 0x1fce0202, 0x20ce0202, 0x21ce0202, 0x22ce0202, 0x23ce0202, 0x24ce0202, + 0x25ce0202, 0x26ce0202, 0x27ce0202, 0x28ce0202, 0x29ce0202, 0x2ace0202, 0x2bce0202, 0x2cce0202, + 0x2dce0202, 0x2ece0202, 0x2fce0202, 0x30ce0202, 0x31ce0202, 0x32ce0202, 0x33ce0202, 0x34ce0202, + 0x35ce0202, 0x36ce0202, 0x37ce0202, 0x38ce0202, 0x39ce0202, 0x3ace0202, 0x3bce0202, 0x3cce0202, + 0x3dce0202, 0x3ece0202, 0x3fce0202, 0x40ce0202, 0x41ce0202, 0x42ce0202, 0x43ce0202, 0x44ce0202, + 0x45ce0202, 0x46ce0202, 0x47ce0202, 0x48ce0202, 0x49ce0202, 0x4ace0202, 0x4bce0202, 0x4cce0202, + 0x4dce0202, 0x4ece0202, 0x4fce0202, 0x50ce0202, 0x51ce0202, 0x52ce0202, 0x53ce0202, 0x54ce0202, + 0x55ce0202, 0x56ce0202, 0x57ce0202, 0x58ce0202, 0x59ce0202, 0x5ace0202, 0x5bce0202, 0x5cce0202, + 0x5dce0202, 0x5ece0202, 0x5fce0202, 0x60ce0202, 0x61ce0202, 0x62ce0202, 0x63ce0202, 0x64ce0202, + 0x65ce0202, 0x66ce0202, 0x67ce0202, 0x68ce0202, 0x69ce0202, 0x6ace0202, 0x6bce0202, 0x6cce0202, + 0x6dce0202, 0x6ece0202, 0x6fce0202, 0x70ce0202, 0x71ce0202, 0x72ce0202, 0x73ce0202, 0x74ce0202, + 0x75ce0202, 0x76ce0202, 0x77ce0202, 0x78ce0202, 0x79ce0202, 0x7ace0202, 0x7bce0202, 0x7cce0202, + 0x7dce0202, 0x7ece0202, 0x7fce0202, 0x80ce0202, 0x81ce0202, 0x82ce0202, 0x83ce0202, 0x84ce0202, + 0x85ce0202, 0x86ce0202, 0x87ce0202, 0x88ce0202, 0x89ce0202, 0x8ace0202, 0x8bce0202, 0x8cce0202, + 0x8dce0202, 0x8ece0202, 0x8fce0202, 0x90ce0202, 0x91ce0202, 0x92ce0202, 0x93ce0202, 0x94ce0202, + 0x95ce0202, 0x96ce0202, 0x97ce0202, 0x98ce0202, 0x99ce0202, 0x9ace0202, 0x9bce0202, 0x9cce0202, + 0x9dce0202, 0x9ece0202, 0x9fce0202, 0xa0ce0202, 0xa1ce0202, 0xa2ce0202, 0xa3ce0202, 0xa4ce0202, + 0xa5ce0202, 0xa6ce0202, 0xa7ce0202, 0xa8ce0202, 0xa9ce0202, 0xaace0202, 0xabce0202, 0xacce0202, + 0xadce0202, 0xaece0202, 0xafce0202, 0xb0ce0202, 0xb1ce0202, 0xb2ce0202, 0xb3ce0202, 0xb4ce0202, + 0xb5ce0202, 0xb6ce0202, 0xb7ce0202, 0xb8ce0202, 0xb9ce0202, 0xbace0202, 0xbbce0202, 0xbcce0202, + 0xbdce0202, 0xbece0202, 0xbfce0202, 0xc0ce0202, 0xc1ce0202, 0xc2ce0202, 0xc3ce0202, 0xc4ce0202, + 0xc5ce0202, 0xc6ce0202, 0xc7ce0202, 0xc8ce0202, 0xc9ce0202, 0xcace0202, 0xcbce0202, 0xccce0202, + 0xcdce0202, 0xcece0202, 0xcfce0202, 0xd0ce0202, 0xd1ce0202, 0xd2ce0202, 0xd3ce0202, 0xd4ce0202, + 0xd5ce0202, 0xd6ce0202, 0xd7ce0202, 0xd8ce0202, 0xd9ce0202, 0xdace0202, 0xdbce0202, 0xdcce0202, + 0xddce0202, 0xdece0202, 0xdfce0202, 0xe0ce0202, 0xe1ce0202, 0xe2ce0202, 0xe3ce0202, 0xe4ce0202, + 0xe5ce0202, 0xe6ce0202, 0xe7ce0202, 0xe8ce0202, 0xe9ce0202, 0xeace0202, 0xebce0202, 0xecce0202, + 0xedce0202, 0xeece0202, 0xefce0202, 0xf0ce0202, 0xf1ce0202, 0xf2ce0202, 0xf3ce0202, 0xf4ce0202, + 0xf5ce0202, 0xf6ce0202, 0xf7ce0202, 0xf8ce0202, 0xf9ce0202, 0xface0202, 0xfbce0202, 0xfcce0202, + 0xfdce0202, 0xfece0202, 0xffce0202, 0x02cf0202, 0x03cf0202, 0x04cf0202, 0x05cf0202, 0x06cf0202, + 0x07cf0202, 0x08cf0202, 0x09cf0202, 0x0acf0202, 0x0bcf0202, 0x0ccf0202, 0x0dcf0202, 0x0ecf0202, + 0x0fcf0202, 0x10cf0202, 0x11cf0202, 0x12cf0202, 0x13cf0202, 0x14cf0202, 0x15cf0202, 0x16cf0202, + 0x17cf0202, 0x18cf0202, 0x19cf0202, 0x1acf0202, 0x1bcf0202, 0x1ccf0202, 0x1dcf0202, 0x1ecf0202, + 0x1fcf0202, 0x20cf0202, 0x21cf0202, 0x22cf0202, 0x23cf0202, 0x24cf0202, 0x25cf0202, 0x26cf0202, + 0x27cf0202, 0x28cf0202, 0x29cf0202, 0x2acf0202, 0x2bcf0202, 0x2ccf0202, 0x2dcf0202, 0x2ecf0202, + 0x2fcf0202, 0x30cf0202, 0x31cf0202, 0x32cf0202, 0x33cf0202, 0x34cf0202, 0x35cf0202, 0x36cf0202, + 0x37cf0202, 0x38cf0202, 0x39cf0202, 0x3acf0202, 0x3bcf0202, 0x3ccf0202, 0x3dcf0202, 0x3ecf0202, + 0x3fcf0202, 0x40cf0202, 0x41cf0202, 0x42cf0202, 0x43cf0202, 0x44cf0202, 0x45cf0202, 0x46cf0202, + 0x47cf0202, 0x48cf0202, 0x49cf0202, 0x4acf0202, 0x4bcf0202, 0x4ccf0202, 0x4dcf0202, 0x4ecf0202, + 0x4fcf0202, 0x50cf0202, 0x51cf0202, 0x52cf0202, 0x53cf0202, 0x54cf0202, 0x55cf0202, 0x56cf0202, + 0x57cf0202, 0x58cf0202, 0x59cf0202, 0x5acf0202, 0x5bcf0202, 0x5ccf0202, 0x5dcf0202, 0x5ecf0202, + 0x5fcf0202, 0x60cf0202, 0x61cf0202, 0x62cf0202, 0x63cf0202, 0x64cf0202, 0x65cf0202, 0x66cf0202, + 0x67cf0202, 0x68cf0202, 0x69cf0202, 0x6acf0202, 0x6bcf0202, 0x6ccf0202, 0x6dcf0202, 0x6ecf0202, + 0x6fcf0202, 0x70cf0202, 0x71cf0202, 0x72cf0202, 0x73cf0202, 0x74cf0202, 0x75cf0202, 0x76cf0202, + 0x77cf0202, 0x78cf0202, 0x79cf0202, 0x7acf0202, 0x7bcf0202, 0x7ccf0202, 0x7dcf0202, 0x7ecf0202, + 0x7fcf0202, 0x80cf0202, 0x81cf0202, 0x82cf0202, 0x83cf0202, 0x84cf0202, 0x85cf0202, 0x86cf0202, + 0x87cf0202, 0x88cf0202, 0x89cf0202, 0x8acf0202, 0x8bcf0202, 0x8ccf0202, 0x8dcf0202, 0x8ecf0202, + 0x8fcf0202, 0x90cf0202, 0x91cf0202, 0x92cf0202, 0x93cf0202, 0x94cf0202, 0x95cf0202, 0x96cf0202, + 0x97cf0202, 0x98cf0202, 0x99cf0202, 0x9acf0202, 0x9bcf0202, 0x9ccf0202, 0x9dcf0202, 0x9ecf0202, + 0x9fcf0202, 0xa0cf0202, 0xa1cf0202, 0xa2cf0202, 0xa3cf0202, 0xa4cf0202, 0xa5cf0202, 0xa6cf0202, + 0xa7cf0202, 0xa8cf0202, 0xa9cf0202, 0xaacf0202, 0xabcf0202, 0xaccf0202, 0xadcf0202, 0xaecf0202, + 0xafcf0202, 0xb0cf0202, 0xb1cf0202, 0xb2cf0202, 0xb3cf0202, 0xb4cf0202, 0xb5cf0202, 0xb6cf0202, + 0xb7cf0202, 0xb8cf0202, 0xb9cf0202, 0xbacf0202, 0xbbcf0202, 0xbccf0202, 0xbdcf0202, 0xbecf0202, + 0xbfcf0202, 0xc0cf0202, 0xc1cf0202, 0xc2cf0202, 0xc3cf0202, 0xc4cf0202, 0xc5cf0202, 0xc6cf0202, + 0xc7cf0202, 0xc8cf0202, 0xc9cf0202, 0xcacf0202, 0xcbcf0202, 0xcccf0202, 0xcdcf0202, 0xcecf0202, + 0xcfcf0202, 0xd0cf0202, 0xd1cf0202, 0xd2cf0202, 0xd3cf0202, 0xd4cf0202, 0xd5cf0202, 0xd6cf0202, + 0xd7cf0202, 0xd8cf0202, 0xd9cf0202, 0xdacf0202, 0xdbcf0202, 0xdccf0202, 0xddcf0202, 0xdecf0202, + 0xdfcf0202, 0xe0cf0202, 0xe1cf0202, 0xe2cf0202, 0xe3cf0202, 0xe4cf0202, 0xe5cf0202, 0xe6cf0202, + 0xe7cf0202, 0xe8cf0202, 0xe9cf0202, 0xeacf0202, 0xebcf0202, 0xeccf0202, 0xedcf0202, 0xeecf0202, + 0xefcf0202, 0xf0cf0202, 0xf1cf0202, 0xf2cf0202, 0xf3cf0202, 0xf4cf0202, 0xf5cf0202, 0xf6cf0202, + 0xf7cf0202, 0xf8cf0202, 0xf9cf0202, 0xfacf0202, 0xfbcf0202, 0xfccf0202, 0xfdcf0202, 0xfecf0202, + 0xffcf0202, 0x02d00202, 0x03d00202, 0x04d00202, 0x05d00202, 0x06d00202, 0x07d00202, 0x08d00202, + 0x09d00202, 0x0ad00202, 0x0bd00202, 0x0cd00202, 0x0dd00202, 0x0ed00202, 0x0fd00202, 0x10d00202, + 0x11d00202, 0x12d00202, 0x13d00202, 0x14d00202, 0x15d00202, 0x16d00202, 0x17d00202, 0x18d00202, + 0x19d00202, 0x1ad00202, 0x1bd00202, 0x1cd00202, 0x1dd00202, 0x1ed00202, 0x1fd00202, 0x20d00202, + 0x21d00202, 0x22d00202, 0x23d00202, 0x24d00202, 0x25d00202, 0x26d00202, 0x27d00202, 0x28d00202, + 0x29d00202, 0x2ad00202, 0x2bd00202, 0x2cd00202, 0x2dd00202, 0x2ed00202, 0x2fd00202, 0x30d00202, + 0x31d00202, 0x32d00202, 0x33d00202, 0x34d00202, 0x35d00202, 0x36d00202, 0x37d00202, 0x38d00202, + 0x39d00202, 0x3ad00202, 0x3bd00202, 0x3cd00202, 0x3dd00202, 0x3ed00202, 0x3fd00202, 0x40d00202, + 0x41d00202, 0x42d00202, 0x43d00202, 0x44d00202, 0x45d00202, 0x46d00202, 0x47d00202, 0x48d00202, + 0x49d00202, 0x4ad00202, 0x4bd00202, 0x4cd00202, 0x4dd00202, 0x4ed00202, 0x4fd00202, 0x50d00202, + 0x51d00202, 0x52d00202, 0x53d00202, 0x54d00202, 0x55d00202, 0x56d00202, 0x57d00202, 0x58d00202, + 0x59d00202, 0x5ad00202, 0x5bd00202, 0x5cd00202, 0x5dd00202, 0x5ed00202, 0x5fd00202, 0x60d00202, + 0x61d00202, 0x62d00202, 0x63d00202, 0x64d00202, 0x65d00202, 0x66d00202, 0x67d00202, 0x68d00202, + 0x69d00202, 0x6ad00202, 0x6bd00202, 0x6cd00202, 0x77d00202, 0x78d00202, 0x79d00202, 0x7ad00202, + 0x7bd00202, 0x7cd00202, 0x7dd00202, 0x7ed00202, 0x7fd00202, 0x80d00202, 0x81d00202, 0x82d00202, + 0x83d00202, 0x84d00202, 0x85d00202, 0x86d00202, 0x87d00202, 0x88d00202, 0x89d00202, 0x8ad00202, + 0x8bd00202, 0x8cd00202, 0x8dd00202, 0x8ed00202, 0x8fd00202, 0x90d00202, 0x91d00202, 0x92d00202, + 0x93d00202, 0x94d00202, 0x95d00202, 0x96d00202, 0x97d00202, 0x98d00202, 0x99d00202, 0x9ad00202, + 0x9bd00202, 0x9cd00202, 0x9dd00202, 0x9ed00202, 0x9fd00202, 0xa0d00202, 0xa1d00202, 0xa2d00202, + 0xa3d00202, 0xa4d00202, 0xa5d00202, 0xa6d00202, 0xa7d00202, 0xa8d00202, 0xa9d00202, 0xaad00202, + 0xabd00202, 0xacd00202, 0xadd00202, 0xaed00202, 0xafd00202, 0xb0d00202, 0xb1d00202, 0xb2d00202, + 0xb3d00202, 0xb4d00202, 0xb5d00202, 0xb6d00202, 0xb7d00202, 0xb8d00202, 0xb9d00202, 0xbad00202, + 0xbbd00202, 0xbcd00202, 0xbdd00202, 0xbed00202, 0xbfd00202, 0xc0d00202, 0xc1d00202, 0xc2d00202, + 0xc3d00202, 0xc4d00202, 0xc5d00202, 0xc6d00202, 0xc7d00202, 0xc8d00202, 0xc9d00202, 0xcad00202, + 0xcbd00202, 0xccd00202, 0xcdd00202, 0xced00202, 0xcfd00202, 0xd0d00202, 0xd1d00202, 0xd2d00202, + 0xd3d00202, 0xd4d00202, 0xd5d00202, 0xd6d00202, 0xd7d00202, 0xd8d00202, 0xd9d00202, 0xdad00202, + 0xdbd00202, 0xdcd00202, 0xddd00202, 0xded00202, 0xdfd00202, 0xe0d00202, 0xe1d00202, 0xe2d00202, + 0xe3d00202, 0xe4d00202, 0xe5d00202, 0xe6d00202, 0xe7d00202, 0xe8d00202, 0xe9d00202, 0xead00202, + 0xebd00202, 0xecd00202, 0xedd00202, 0xeed00202, 0xefd00202, 0xf0d00202, 0xf1d00202, 0xf2d00202, + 0xf3d00202, 0xf4d00202, 0xf5d00202, 0xf6d00202, 0xf7d00202, 0xf8d00202, 0xf9d00202, 0xfad00202, + 0xfbd00202, 0xfcd00202, 0xfdd00202, 0xfed00202, 0xffd00202, 0x02d10202, 0x03d10202, 0x04d10202, + 0x05d10202, 0x06d10202, 0x07d10202, 0x08d10202, 0x09d10202, 0x0ad10202, 0x0bd10202, 0x0cd10202, + 0x0dd10202, 0x0ed10202, 0x0fd10202, 0x10d10202, 0x11d10202, 0x12d10202, 0x13d10202, 0x14d10202, + 0x15d10202, 0x16d10202, 0x17d10202, 0x18d10202, 0x19d10202, 0x1ad10202, 0x1bd10202, 0x1cd10202, + 0x1dd10202, 0x1ed10202, 0x1fd10202, 0x20d10202, 0x21d10202, 0x22d10202, 0x23d10202, 0x24d10202, + 0x25d10202, 0x26d10202, 0x27d10202, 0x28d10202, 0x29d10202, 0x2ad10202, 0x2bd10202, 0x2cd10202, + 0x2dd10202, 0x2ed10202, 0x2fd10202, 0x30d10202, 0x31d10202, 0x32d10202, 0x33d10202, 0x34d10202, + 0x35d10202, 0x36d10202, 0x37d10202, 0x38d10202, 0x39d10202, 0x3ad10202, 0x3bd10202, 0x3cd10202, + 0x3dd10202, 0x3ed10202, 0x3fd10202, 0x40d10202, 0x41d10202, 0x42d10202, 0x43d10202, 0x44d10202, + 0x45d10202, 0x46d10202, 0x47d10202, 0x48d10202, 0x49d10202, 0x4ad10202, 0x4bd10202, 0x4cd10202, + 0x4dd10202, 0x4ed10202, 0x4fd10202, 0x50d10202, 0x51d10202, 0x52d10202, 0x53d10202, 0x54d10202, + 0x55d10202, 0x56d10202, 0x57d10202, 0x58d10202, 0x59d10202, 0x5ad10202, 0x5bd10202, 0x5cd10202, + 0x5dd10202, 0x5ed10202, 0x5fd10202, 0x60d10202, 0x61d10202, 0x62d10202, 0x63d10202, 0x64d10202, + 0x65d10202, 0x66d10202, 0x67d10202, 0x68d10202, 0x69d10202, 0x6ad10202, 0x6bd10202, 0x6cd10202, + 0x6dd10202, 0x6ed10202, 0x6fd10202, 0x70d10202, 0x71d10202, 0x72d10202, 0x73d10202, 0x74d10202, + 0x75d10202, 0x76d10202, 0x77d10202, 0x78d10202, 0x79d10202, 0x7ad10202, 0x7bd10202, 0x7cd10202, + 0x7dd10202, 0x7ed10202, 0x7fd10202, 0x80d10202, 0x81d10202, 0x82d10202, 0x83d10202, 0x84d10202, + 0x85d10202, 0x86d10202, 0x87d10202, 0x88d10202, 0x89d10202, 0x8ad10202, 0x8bd10202, 0x8cd10202, + 0x8dd10202, 0x8ed10202, 0x8fd10202, 0x90d10202, 0x91d10202, 0x92d10202, 0x93d10202, 0x94d10202, + 0x95d10202, 0x96d10202, 0x97d10202, 0x98d10202, 0x99d10202, 0x9ad10202, 0x9bd10202, 0x9cd10202, + 0x9dd10202, 0x9ed10202, 0x9fd10202, 0xa0d10202, 0xa1d10202, 0xa2d10202, 0xa3d10202, 0xa4d10202, + 0xa5d10202, 0xa6d10202, 0xa7d10202, 0xa8d10202, 0xa9d10202, 0xaad10202, 0xabd10202, 0xacd10202, + 0xadd10202, 0xaed10202, 0xafd10202, 0xb0d10202, 0xb1d10202, 0xb2d10202, 0xb3d10202, 0xb4d10202, + 0xb5d10202, 0xb6d10202, 0xb7d10202, 0xb8d10202, 0xb9d10202, 0xbad10202, 0xbbd10202, 0xbcd10202, + 0xbdd10202, 0xbed10202, 0xbfd10202, 0xc0d10202, 0xc1d10202, 0xc2d10202, 0xc3d10202, 0xc4d10202, + 0xc5d10202, 0xc6d10202, 0xc7d10202, 0xc8d10202, 0xc9d10202, 0xcad10202, 0xcbd10202, 0xccd10202, + 0xcdd10202, 0xced10202, 0xcfd10202, 0xd0d10202, 0xd1d10202, 0xd2d10202, 0xd3d10202, 0xd4d10202, + 0xd5d10202, 0xd6d10202, 0xd7d10202, 0xd8d10202, 0xd9d10202, 0xdad10202, 0xdbd10202, 0xdcd10202, + 0xddd10202, 0xded10202, 0xdfd10202, 0xe0d10202, 0xe1d10202, 0xe2d10202, 0xe3d10202, 0xe4d10202, + 0xe5d10202, 0xe6d10202, 0xe7d10202, 0xe8d10202, 0xe9d10202, 0xead10202, 0xebd10202, 0xecd10202, + 0xedd10202, 0xeed10202, 0xefd10202, 0xf0d10202, 0xf1d10202, 0xf2d10202, 0xf3d10202, 0xf4d10202, + 0xf5d10202, 0xf6d10202, 0xf7d10202, 0xf8d10202, 0xf9d10202, 0xfad10202, 0xfbd10202, 0xfcd10202, + 0xfdd10202, 0xfed10202, 0xffd10202, 0x02d20202, 0x03d20202, 0x04d20202, 0x05d20202, 0x06d20202, + 0x07d20202, 0x08d20202, 0x09d20202, 0x0ad20202, 0x0bd20202, 0x0cd20202, 0x0dd20202, 0x0ed20202, + 0x0fd20202, 0x10d20202, 0x11d20202, 0x12d20202, 0x13d20202, 0x14d20202, 0x15d20202, 0x16d20202, + 0x17d20202, 0x18d20202, 0x19d20202, 0x1ad20202, 0x1bd20202, 0x1cd20202, 0x1dd20202, 0x1ed20202, + 0x1fd20202, 0x20d20202, 0x21d20202, 0x22d20202, 0x23d20202, 0x24d20202, 0x25d20202, 0x26d20202, + 0x27d20202, 0x28d20202, 0x29d20202, 0x2ad20202, 0x2bd20202, 0x2cd20202, 0x2dd20202, 0x2ed20202, + 0x2fd20202, 0x30d20202, 0x31d20202, 0x32d20202, 0x33d20202, 0x34d20202, 0x35d20202, 0x36d20202, + 0x37d20202, 0x38d20202, 0x39d20202, 0x3ad20202, 0x3bd20202, 0x3cd20202, 0x3dd20202, 0x3ed20202, + 0x3fd20202, 0x40d20202, 0x41d20202, 0x42d20202, 0x43d20202, 0x44d20202, 0x45d20202, 0x46d20202, + 0x47d20202, 0x48d20202, 0x49d20202, 0x4ad20202, 0x4bd20202, 0x4cd20202, 0x4dd20202, 0x4ed20202, + 0x4fd20202, 0x50d20202, 0x51d20202, 0x52d20202, 0x53d20202, 0x54d20202, 0x55d20202, 0x56d20202, + 0x57d20202, 0x58d20202, 0x59d20202, 0x5ad20202, 0x5bd20202, 0x5cd20202, 0x5dd20202, 0x5ed20202, + 0x5fd20202, 0x60d20202, 0x61d20202, 0x62d20202, 0x63d20202, 0x64d20202, 0x65d20202, 0x66d20202, + 0x67d20202, 0x68d20202, 0x69d20202, 0x6ad20202, 0x6bd20202, 0x6cd20202, 0x6dd20202, 0x6ed20202, + 0x6fd20202, 0x70d20202, 0x71d20202, 0x72d20202, 0x73d20202, 0x74d20202, 0x75d20202, 0x76d20202, + 0x77d20202, 0x78d20202, 0x79d20202, 0x7ad20202, 0x7bd20202, 0x7cd20202, 0x7dd20202, 0x7ed20202, + 0x7fd20202, 0x80d20202, 0x81d20202, 0x82d20202, 0x83d20202, 0x84d20202, 0x85d20202, 0x86d20202, + 0x87d20202, 0x88d20202, 0x89d20202, 0x8ad20202, 0x8bd20202, 0x8cd20202, 0x8dd20202, 0x8ed20202, + 0x8fd20202, 0x90d20202, 0x91d20202, 0x92d20202, 0x93d20202, 0x94d20202, 0x95d20202, 0x96d20202, + 0x97d20202, 0x98d20202, 0x99d20202, 0x9ad20202, 0x9bd20202, 0x9cd20202, 0x9dd20202, 0x9ed20202, + 0x9fd20202, 0xa0d20202, 0xa1d20202, 0xa2d20202, 0xa3d20202, 0xa4d20202, 0xa5d20202, 0xa6d20202, + 0xa7d20202, 0xa8d20202, 0xa9d20202, 0xaad20202, 0xabd20202, 0xadd20202, 0xaed20202, 0xafd20202, + 0xb0d20202, 0xb1d20202, 0xb2d20202, 0xb3d20202, 0xb4d20202, 0xb5d20202, 0xb6d20202, 0xb7d20202, + 0xb8d20202, 0xb9d20202, 0xbad20202, 0xbbd20202, 0xbcd20202, 0xbdd20202, 0xbed20202, 0xbfd20202, + 0xc0d20202, 0xc1d20202, 0xc2d20202, 0xc3d20202, 0xc4d20202, 0xc5d20202, 0xc6d20202, 0xc7d20202, + 0xcdd20202, 0xced20202, 0xcfd20202, 0xd0d20202, 0xd1d20202, 0xd2d20202, 0xd3d20202, 0xd4d20202, + 0xd5d20202, 0xd6d20202, 0xd7d20202, 0xd8d20202, 0xd9d20202, 0xdad20202, 0xdbd20202, 0xdcd20202, + 0xddd20202, 0xded20202, 0xdfd20202, 0xe0d20202, 0xe1d20202, 0xe2d20202, 0xe3d20202, 0xe4d20202, + 0xe5d20202, 0xe6d20202, 0xe7d20202, 0xe8d20202, 0xe9d20202, 0xead20202, 0xebd20202, 0xecd20202, + 0xedd20202, 0xeed20202, 0xefd20202, 0xf0d20202, 0xf1d20202, 0xf2d20202, 0xf3d20202, 0xf4d20202, + 0xf5d20202, 0xf6d20202, 0xf7d20202, 0xf8d20202, 0xf9d20202, 0xfad20202, 0xfbd20202, 0xfcd20202, + 0xfdd20202, 0xfed20202, 0xffd20202, 0x02d30202, 0x03d30202, 0x04d30202, 0x05d30202, 0x06d30202, + 0x07d30202, 0x08d30202, 0x09d30202, 0x0ad30202, 0x0bd30202, 0x0cd30202, 0x0dd30202, 0x0ed30202, + 0x0fd30202, 0x10d30202, 0x11d30202, 0x12d30202, 0x13d30202, 0x14d30202, 0x15d30202, 0x16d30202, + 0x17d30202, 0x18d30202, 0x19d30202, 0x1ad30202, 0x1bd30202, 0x1cd30202, 0x1dd30202, 0x1ed30202, + 0x1fd30202, 0x20d30202, 0x21d30202, 0x22d30202, 0x23d30202, 0x24d30202, 0x25d30202, 0x26d30202, + 0x27d30202, 0x28d30202, 0x29d30202, 0x2ad30202, 0x2bd30202, 0x2cd30202, 0x2dd30202, 0x2ed30202, + 0x2fd30202, 0x30d30202, 0x31d30202, 0x32d30202, 0x33d30202, 0x34d30202, 0x35d30202, 0x36d30202, + 0x37d30202, 0x38d30202, 0x39d30202, 0x3ad30202, 0x3bd30202, 0x3cd30202, 0x3dd30202, 0x3ed30202, + 0x3fd30202, 0x40d30202, 0x41d30202, 0x42d30202, 0x43d30202, 0x44d30202, 0x45d30202, 0x46d30202, + 0x47d30202, 0x48d30202, 0x49d30202, 0x4ad30202, 0x4bd30202, 0x4cd30202, 0x4dd30202, 0x4ed30202, + 0x4fd30202, 0x50d30202, 0x51d30202, 0x52d30202, 0x53d30202, 0x54d30202, 0x55d30202, 0x56d30202, + 0x57d30202, 0x58d30202, 0x59d30202, 0x5ad30202, 0x5bd30202, 0x5cd30202, 0x5dd30202, 0x5ed30202, + 0x5fd30202, 0x60d30202, 0x61d30202, 0x62d30202, 0x63d30202, 0x64d30202, 0x65d30202, 0x66d30202, + 0x67d30202, 0x68d30202, 0x69d30202, 0x6ad30202, 0x6bd30202, 0x6cd30202, 0x6dd30202, 0x6ed30202, + 0x6fd30202, 0x70d30202, 0x71d30202, 0x72d30202, 0x73d30202, 0x74d30202, 0x75d30202, 0x76d30202, + 0x77d30202, 0x78d30202, 0x79d30202, 0x7ad30202, 0x7bd30202, 0x7cd30202, 0x7dd30202, 0x7ed30202, + 0x7fd30202, 0x80d30202, 0x81d30202, 0x82d30202, 0x83d30202, 0x84d30202, 0x85d30202, 0x86d30202, + 0x87d30202, 0x88d30202, 0x89d30202, 0x8ad30202, 0x8bd30202, 0x8cd30202, 0x8dd30202, 0x8ed30202, + 0x8fd30202, 0x90d30202, 0x91d30202, 0x92d30202, 0x93d30202, 0x94d30202, 0x95d30202, 0x96d30202, + 0x97d30202, 0x98d30202, 0x99d30202, 0x9ad30202, 0x9bd30202, 0x9cd30202, 0x9dd30202, 0x9ed30202, + 0x9fd30202, 0xa0d30202, 0xa1d30202, 0xa2d30202, 0xa3d30202, 0xa4d30202, 0xa5d30202, 0xa6d30202, + 0xa7d30202, 0xa8d30202, 0xa9d30202, 0xaad30202, 0xabd30202, 0xacd30202, 0xadd30202, 0xaed30202, + 0xafd30202, 0xb0d30202, 0xb1d30202, 0xb2d30202, 0xb3d30202, 0xb4d30202, 0xb5d30202, 0xb6d30202, + 0xb7d30202, 0xb8d30202, 0xb9d30202, 0xbad30202, 0xbbd30202, 0xbcd30202, 0xbdd30202, 0xbed30202, + 0xbfd30202, 0xc0d30202, 0xc1d30202, 0xc2d30202, 0xc3d30202, 0xc4d30202, 0xc5d30202, 0xc6d30202, + 0xc7d30202, 0xc8d30202, 0xc9d30202, 0xcad30202, 0xcbd30202, 0xccd30202, 0xcdd30202, 0xced30202, + 0xcfd30202, 0xd0d30202, 0xd1d30202, 0xd2d30202, 0xd3d30202, 0xd4d30202, 0xd5d30202, 0xd6d30202, + 0xd7d30202, 0xd8d30202, 0xd9d30202, 0xdad30202, 0xdbd30202, 0xdcd30202, 0xddd30202, 0xded30202, + 0xdfd30202, 0xe0d30202, 0xe1d30202, 0xe2d30202, 0xe3d30202, 0xe4d30202, 0xe5d30202, 0xe6d30202, + 0xe7d30202, 0xe8d30202, 0xe9d30202, 0xead30202, 0xebd30202, 0xecd30202, 0xedd30202, 0xeed30202, + 0xefd30202, 0xf0d30202, 0xf1d30202, 0xf2d30202, 0xf3d30202, 0xf4d30202, 0xf5d30202, 0xf6d30202, + 0xf7d30202, 0xf8d30202, 0xf9d30202, 0xfad30202, 0xfbd30202, 0xfcd30202, 0xfdd30202, 0xfed30202, + 0xffd30202, 0x02d40202, 0x03d40202, 0x04d40202, 0x05d40202, 0x06d40202, 0x07d40202, 0x08d40202, + 0x09d40202, 0x0ad40202, 0x0bd40202, 0x0cd40202, 0x0dd40202, 0x0ed40202, 0x0fd40202, 0x10d40202, + 0x11d40202, 0x12d40202, 0x13d40202, 0x14d40202, 0x15d40202, 0x16d40202, 0x17d40202, 0x18d40202, + 0x19d40202, 0x1ad40202, 0x1bd40202, 0x1cd40202, 0x1dd40202, 0x1ed40202, 0x1fd40202, 0x20d40202, + 0x21d40202, 0x22d40202, 0x23d40202, 0x24d40202, 0x25d40202, 0x26d40202, 0x27d40202, 0x28d40202, + 0x29d40202, 0x2ad40202, 0x2bd40202, 0x2cd40202, 0x2dd40202, 0x2ed40202, 0x2fd40202, 0x30d40202, + 0x31d40202, 0x32d40202, 0x33d40202, 0x34d40202, 0x35d40202, 0x36d40202, 0x37d40202, 0x38d40202, + 0x39d40202, 0x3ad40202, 0x3bd40202, 0x3cd40202, 0x3dd40202, 0x3ed40202, 0x3fd40202, 0x40d40202, + 0x41d40202, 0x42d40202, 0x43d40202, 0x44d40202, 0x45d40202, 0x46d40202, 0x47d40202, 0x48d40202, + 0x49d40202, 0x4ad40202, 0x4bd40202, 0x4cd40202, 0x4dd40202, 0x4ed40202, 0x4fd40202, 0x50d40202, + 0x51d40202, 0x52d40202, 0x53d40202, 0x54d40202, 0x55d40202, 0x56d40202, 0x57d40202, 0x58d40202, + 0x59d40202, 0x5ad40202, 0x5bd40202, 0x5cd40202, 0x5dd40202, 0x5ed40202, 0x5fd40202, 0x60d40202, + 0x61d40202, 0x62d40202, 0x63d40202, 0x64d40202, 0x65d40202, 0x66d40202, 0x67d40202, 0x68d40202, + 0x69d40202, 0x6ad40202, 0x6bd40202, 0x6cd40202, 0x6dd40202, 0x6ed40202, 0x6fd40202, 0x70d40202, + 0x71d40202, 0x72d40202, 0x73d40202, 0x74d40202, 0x75d40202, 0x76d40202, 0x77d40202, 0x78d40202, + 0x79d40202, 0x7ad40202, 0x7bd40202, 0x7cd40202, 0x7dd40202, 0x7ed40202, 0x7fd40202, 0x80d40202, + 0x81d40202, 0x82d40202, 0x83d40202, 0x84d40202, 0x85d40202, 0x86d40202, 0x87d40202, 0x88d40202, + 0x89d40202, 0x8ad40202, 0x8bd40202, 0x8cd40202, 0x8dd40202, 0x8ed40202, 0x8fd40202, 0x90d40202, + 0x91d40202, 0x92d40202, 0x93d40202, 0x94d40202, 0x95d40202, 0x96d40202, 0x97d40202, 0x98d40202, + 0x99d40202, 0x9ad40202, 0x9bd40202, 0x9cd40202, 0x9dd40202, 0x9ed40202, 0x9fd40202, 0xa0d40202, + 0xa1d40202, 0xa2d40202, 0xa3d40202, 0xa4d40202, 0xa5d40202, 0xa6d40202, 0xa7d40202, 0xa8d40202, + 0xa9d40202, 0xaad40202, 0xabd40202, 0xacd40202, 0xadd40202, 0xaed40202, 0xafd40202, 0xb0d40202, + 0xb1d40202, 0xb2d40202, 0xb3d40202, 0xb4d40202, 0xb5d40202, 0xb6d40202, 0xb7d40202, 0xb8d40202, + 0xb9d40202, 0xbad40202, 0xbbd40202, 0xbcd40202, 0xbdd40202, 0xbed40202, 0xbfd40202, 0xc0d40202, + 0xc1d40202, 0xc2d40202, 0xc3d40202, 0xc4d40202, 0xc5d40202, 0xc6d40202, 0xc7d40202, 0xc8d40202, + 0xc9d40202, 0xcad40202, 0xcbd40202, 0xccd40202, 0xcdd40202, 0xced40202, 0xcfd40202, 0xd0d40202, + 0xd1d40202, 0xd2d40202, 0xd3d40202, 0xd4d40202, 0xd5d40202, 0xd6d40202, 0xd7d40202, 0xd8d40202, + 0xd9d40202, 0xdad40202, 0xdbd40202, 0xdcd40202, 0xddd40202, 0xded40202, 0xdfd40202, 0xe0d40202, + 0xe1d40202, 0xe2d40202, 0xe3d40202, 0xe4d40202, 0xe5d40202, 0xe6d40202, 0xe7d40202, 0xe8d40202, + 0xe9d40202, 0xead40202, 0xebd40202, 0xecd40202, 0xedd40202, 0xeed40202, 0xefd40202, 0xf0d40202, + 0xf1d40202, 0xf2d40202, 0xf3d40202, 0xf4d40202, 0xf5d40202, 0xf6d40202, 0xf7d40202, 0xf8d40202, + 0xf9d40202, 0xfad40202, 0xfbd40202, 0xfcd40202, 0xfdd40202, 0xfed40202, 0xffd40202, 0x02d50202, + 0x03d50202, 0x04d50202, 0x05d50202, 0x06d50202, 0x07d50202, 0x08d50202, 0x09d50202, 0x0ad50202, + 0x0bd50202, 0x0cd50202, 0x0dd50202, 0x0ed50202, 0x0fd50202, 0x10d50202, 0x11d50202, 0x12d50202, + 0x13d50202, 0x14d50202, 0x15d50202, 0x16d50202, 0x17d50202, 0x18d50202, 0x19d50202, 0x1ad50202, + 0x1bd50202, 0x1cd50202, 0x1dd50202, 0x1ed50202, 0x2dd50202, 0x2fd50202, 0x30d50202, 0x31d50202, + 0x32d50202, 0x33d50202, 0x34d50202, 0x35d50202, 0x36d50202, 0x37d50202, 0x38d50202, 0x39d50202, + 0x3ad50202, 0x3bd50202, 0x3cd50202, 0x3dd50202, 0x3ed50202, 0x3fd50202, 0x40d50202, 0x41d50202, + 0x42d50202, 0x43d50202, 0x44d50202, 0x45d50202, 0x46d50202, 0x47d50202, 0x48d50202, 0x49d50202, + 0x4ad50202, 0x4bd50202, 0x4cd50202, 0x4dd50202, 0x4ed50202, 0x4fd50202, 0x50d50202, 0x51d50202, + 0x52d50202, 0x53d50202, 0x54d50202, 0x55d50202, 0x56d50202, 0x57d50202, 0x58d50202, 0x59d50202, + 0x5ad50202, 0x5bd50202, 0x5cd50202, 0x5dd50202, 0x5ed50202, 0x5fd50202, 0x60d50202, 0x61d50202, + 0x62d50202, 0x63d50202, 0x64d50202, 0x65d50202, 0x66d50202, 0x67d50202, 0x68d50202, 0x69d50202, + 0x6ad50202, 0x6bd50202, 0x6cd50202, 0x6dd50202, 0x6ed50202, 0x6fd50202, 0x70d50202, 0x71d50202, + 0x72d50202, 0x73d50202, 0x74d50202, 0x75d50202, 0x76d50202, 0x77d50202, 0x78d50202, 0x79d50202, + 0x7ad50202, 0x7bd50202, 0x7cd50202, 0x7dd50202, 0x7ed50202, 0x7fd50202, 0x80d50202, 0x81d50202, + 0x82d50202, 0x83d50202, 0x84d50202, 0x85d50202, 0x86d50202, 0x87d50202, 0x88d50202, 0x89d50202, + 0x8ad50202, 0x8bd50202, 0x8cd50202, 0x8dd50202, 0x8ed50202, 0x8fd50202, 0x90d50202, 0x91d50202, + 0x92d50202, 0x93d50202, 0x94d50202, 0x95d50202, 0x96d50202, 0x97d50202, 0x98d50202, 0x99d50202, + 0x9ad50202, 0x9bd50202, 0x9cd50202, 0x9dd50202, 0x9ed50202, 0x9fd50202, 0xa0d50202, 0xa1d50202, + 0xa2d50202, 0xa3d50202, 0xa4d50202, 0xa5d50202, 0xa6d50202, 0xa7d50202, 0xa8d50202, 0xa9d50202, + 0xaad50202, 0xabd50202, 0xacd50202, 0xadd50202, 0xaed50202, 0xafd50202, 0xb0d50202, 0xb1d50202, + 0xb2d50202, 0xb3d50202, 0xb4d50202, 0xb5d50202, 0xb6d50202, 0xb7d50202, 0xb8d50202, 0xb9d50202, + 0xbad50202, 0xbbd50202, 0xbcd50202, 0xbdd50202, 0xbed50202, 0xbfd50202, 0xc0d50202, 0xc1d50202, + 0xc2d50202, 0xc3d50202, 0xc4d50202, 0xc5d50202, 0xc6d50202, 0xc7d50202, 0xc8d50202, 0xc9d50202, + 0xcad50202, 0xcbd50202, 0xccd50202, 0xcdd50202, 0xced50202, 0xcfd50202, 0xd0d50202, 0xd1d50202, + 0xd2d50202, 0xd3d50202, 0xd4d50202, 0xd5d50202, 0xd6d50202, 0xd7d50202, 0xd8d50202, 0xd9d50202, + 0xdad50202, 0xdbd50202, 0xdcd50202, 0xddd50202, 0xded50202, 0xdfd50202, 0xe0d50202, 0xe1d50202, + 0xe2d50202, 0xe3d50202, 0xe4d50202, 0xe5d50202, 0xe6d50202, 0xe7d50202, 0xe8d50202, 0xe9d50202, + 0xead50202, 0xebd50202, 0xecd50202, 0xedd50202, 0xeed50202, 0xefd50202, 0xf0d50202, 0xf1d50202, + 0xf2d50202, 0xf3d50202, 0xf4d50202, 0xf5d50202, 0xf6d50202, 0xf7d50202, 0xf8d50202, 0xf9d50202, + 0xfad50202, 0xfbd50202, 0xfcd50202, 0xfdd50202, 0xfed50202, 0xffd50202, 0x02d60202, 0x03d60202, + 0x04d60202, 0x05d60202, 0x06d60202, 0x07d60202, 0x08d60202, 0x09d60202, 0x0ad60202, 0x0bd60202, + 0x0cd60202, 0x0dd60202, 0x0ed60202, 0x0fd60202, 0x10d60202, 0x11d60202, 0x12d60202, 0x13d60202, + 0x14d60202, 0x15d60202, 0x16d60202, 0x17d60202, 0x18d60202, 0x19d60202, 0x1ad60202, 0x1bd60202, + 0x1cd60202, 0x1dd60202, 0x1ed60202, 0x1fd60202, 0x20d60202, 0x21d60202, 0x22d60202, 0x23d60202, + 0x24d60202, 0x25d60202, 0x26d60202, 0x27d60202, 0x28d60202, 0x29d60202, 0x2ad60202, 0x2bd60202, + 0x2cd60202, 0x2dd60202, 0x2ed60202, 0x2fd60202, 0x30d60202, 0x31d60202, 0x32d60202, 0x33d60202, + 0x34d60202, 0x35d60202, 0x36d60202, 0x37d60202, 0x38d60202, 0x39d60202, 0x3ad60202, 0x3bd60202, + 0x3cd60202, 0x3dd60202, 0x3ed60202, 0x3fd60202, 0x40d60202, 0x41d60202, 0x42d60202, 0x43d60202, + 0x44d60202, 0x45d60202, 0x46d60202, 0x47d60202, 0x48d60202, 0x49d60202, 0x4ad60202, 0x4bd60202, + 0x4cd60202, 0x4dd60202, 0x4ed60202, 0x4fd60202, 0x50d60202, 0x51d60202, 0x52d60202, 0x53d60202, + 0x54d60202, 0x55d60202, 0x56d60202, 0x57d60202, 0x58d60202, 0x59d60202, 0x5ad60202, 0x5bd60202, + 0x5cd60202, 0x5dd60202, 0x5ed60202, 0x5fd60202, 0x60d60202, 0x61d60202, 0x62d60202, 0x63d60202, + 0x64d60202, 0x65d60202, 0x66d60202, 0x67d60202, 0x68d60202, 0x69d60202, 0x6ad60202, 0x6bd60202, + 0x6cd60202, 0x6dd60202, 0x6ed60202, 0x6fd60202, 0x70d60202, 0x71d60202, 0x72d60202, 0x73d60202, + 0x74d60202, 0x75d60202, 0x76d60202, 0x77d60202, 0x78d60202, 0x79d60202, 0x7ad60202, 0x7bd60202, + 0x7cd60202, 0x7dd60202, 0x7ed60202, 0x7fd60202, 0x80d60202, 0x81d60202, 0x82d60202, 0x83d60202, + 0x84d60202, 0x85d60202, 0x86d60202, 0x87d60202, 0x88d60202, 0x89d60202, 0x8ad60202, 0x8bd60202, + 0x8cd60202, 0x8dd60202, 0x8ed60202, 0x8fd60202, 0x90d60202, 0x91d60202, 0x92d60202, 0x93d60202, + 0x94d60202, 0x95d60202, 0x96d60202, 0x97d60202, 0x98d60202, 0x99d60202, 0x9ad60202, 0x9bd60202, + 0x9cd60202, 0x9ed60202, 0x9fd60202, 0xa0d60202, 0xa1d60202, 0xa2d60202, 0xa3d60202, 0xa4d60202, + 0xa5d60202, 0xa6d60202, 0xa7d60202, 0xa8d60202, 0xa9d60202, 0xaad60202, 0xabd60202, 0xacd60202, + 0xadd60202, 0xaed60202, 0xafd60202, 0xb0d60202, 0xb1d60202, 0xb2d60202, 0xb3d60202, 0xb4d60202, + 0xb5d60202, 0xb6d60202, 0xb7d60202, 0xb8d60202, 0xb9d60202, 0xbad60202, 0xbbd60202, 0xbcd60202, + 0xbdd60202, 0xbed60202, 0xbfd60202, 0xc0d60202, 0xc1d60202, 0xc2d60202, 0xc3d60202, 0xc4d60202, + 0xc5d60202, 0xc6d60202, 0xc7d60202, 0xc8d60202, 0xc9d60202, 0xcad60202, 0xcbd60202, 0xccd60202, + 0xcdd60202, 0xced60202, 0xcfd60202, 0xd0d60202, 0xd1d60202, 0xd2d60202, 0xd3d60202, 0xd4d60202, + 0xd5d60202, 0xd6d60202, 0xd7d60202, 0xd8d60202, 0xd9d60202, 0xdad60202, 0xdbd60202, 0xdcd60202, + 0xddd60202, 0xded60202, 0xdfd60202, 0xe0d60202, 0xe1d60202, 0xe2d60202, 0xe3d60202, 0xe4d60202, + 0xe5d60202, 0xe6d60202, 0xe7d60202, 0xe8d60202, 0xe9d60202, 0xead60202, 0xebd60202, 0xecd60202, + 0xedd60202, 0xeed60202, 0xefd60202, 0xf0d60202, 0xf1d60202, 0xf2d60202, 0xf3d60202, 0xf4d60202, + 0xf5d60202, 0xf6d60202, 0xf7d60202, 0xf8d60202, 0xf9d60202, 0xfad60202, 0xfbd60202, 0xfcd60202, + 0xfdd60202, 0xfed60202, 0xffd60202, 0x02d70202, 0x03d70202, 0x04d70202, 0x05d70202, 0x06d70202, + 0x07d70202, 0x08d70202, 0x09d70202, 0x0ad70202, 0x0bd70202, 0x0cd70202, 0x0dd70202, 0x0ed70202, + 0x0fd70202, 0x10d70202, 0x11d70202, 0x12d70202, 0x13d70202, 0x14d70202, 0x15d70202, 0x16d70202, + 0x17d70202, 0x18d70202, 0x19d70202, 0x1ad70202, 0x1bd70202, 0x1cd70202, 0x1dd70202, 0x1ed70202, + 0x1fd70202, 0x20d70202, 0x21d70202, 0x22d70202, 0x23d70202, 0x24d70202, 0x25d70202, 0x26d70202, + 0x27d70202, 0x28d70202, 0x29d70202, 0x2ad70202, 0x2bd70202, 0x2cd70202, 0x2dd70202, 0x2ed70202, + 0x2fd70202, 0x30d70202, 0x31d70202, 0x32d70202, 0x33d70202, 0x34d70202, 0x35d70202, 0x36d70202, + 0x37d70202, 0x38d70202, 0x39d70202, 0x3ad70202, 0x3bd70202, 0x3cd70202, 0x3dd70202, 0x3ed70202, + 0x3fd70202, 0x40d70202, 0x41d70202, 0x42d70202, 0x43d70202, 0x44d70202, 0x45d70202, 0x46d70202, + 0x47d70202, 0x48d70202, 0x49d70202, 0x4ad70202, 0x4bd70202, 0x4cd70202, 0x4dd70202, 0x4ed70202, + 0x4fd70202, 0x50d70202, 0x51d70202, 0x52d70202, 0x53d70202, 0x54d70202, 0x55d70202, 0x56d70202, + 0x57d70202, 0x58d70202, 0x59d70202, 0x5ad70202, 0x5bd70202, 0x5cd70202, 0x5dd70202, 0x5ed70202, + 0x5fd70202, 0x60d70202, 0x61d70202, 0x62d70202, 0x63d70202, 0x64d70202, 0x65d70202, 0x66d70202, + 0x67d70202, 0x68d70202, 0x69d70202, 0x6ad70202, 0x6bd70202, 0x6cd70202, 0x6dd70202, 0x6ed70202, + 0x6fd70202, 0x70d70202, 0x71d70202, 0x72d70202, 0x73d70202, 0x74d70202, 0x75d70202, 0x76d70202, + 0x77d70202, 0x78d70202, 0x79d70202, 0x7ad70202, 0x7bd70202, 0x7cd70202, 0x7dd70202, 0x7ed70202, + 0x87d70202, 0x88d70202, 0x89d70202, 0x8ad70202, 0x8bd70202, 0x8cd70202, 0x8dd70202, 0x8ed70202, + 0x8fd70202, 0x90d70202, 0x91d70202, 0x92d70202, 0x93d70202, 0x94d70202, 0x95d70202, 0x96d70202, + 0x97d70202, 0x98d70202, 0x99d70202, 0x9ad70202, 0x9bd70202, 0x9cd70202, 0x9dd70202, 0x9ed70202, + 0x9fd70202, 0xa0d70202, 0xa1d70202, 0xa2d70202, 0xa3d70202, 0xa4d70202, 0xa5d70202, 0xa6d70202, + 0xa7d70202, 0xa8d70202, 0xa9d70202, 0xaad70202, 0xabd70202, 0xacd70202, 0xadd70202, 0xaed70202, + 0xafd70202, 0xb0d70202, 0xb1d70202, 0xb2d70202, 0xb3d70202, 0xb4d70202, 0xb5d70202, 0xb6d70202, + 0xb7d70202, 0xb8d70202, 0xb9d70202, 0xbad70202, 0xbbd70202, 0xbcd70202, 0xbdd70202, 0xbed70202, + 0xbfd70202, 0xc0d70202, 0xc1d70202, 0xc2d70202, 0xc3d70202, 0xc4d70202, 0xc5d70202, 0xc6d70202, + 0xc7d70202, 0xc8d70202, 0xc9d70202, 0xcad70202, 0xcbd70202, 0xccd70202, 0xcdd70202, 0xced70202, + 0xcfd70202, 0xd0d70202, 0xd1d70202, 0xd2d70202, 0xd3d70202, 0xd4d70202, 0xd5d70202, 0xd6d70202, + 0xd7d70202, 0xd8d70202, 0xd9d70202, 0xdad70202, 0xdbd70202, 0xdcd70202, 0xddd70202, 0xded70202, + 0xdfd70202, 0xe0d70202, 0xe1d70202, 0xe2d70202, 0xe3d70202, 0xe4d70202, 0xe5d70202, 0xe6d70202, + 0xe7d70202, 0xe8d70202, 0xe9d70202, 0xead70202, 0xebd70202, 0xecd70202, 0xedd70202, 0xeed70202, + 0xefd70202, 0xf0d70202, 0xf1d70202, 0xf2d70202, 0xf3d70202, 0xf4d70202, 0xf5d70202, 0xf6d70202, + 0xf7d70202, 0xf8d70202, 0xf9d70202, 0xfad70202, 0xfbd70202, 0xfcd70202, 0xfdd70202, 0xfed70202, + 0xffd70202, 0x02d80202, 0x03d80202, 0x04d80202, 0x05d80202, 0x06d80202, 0x07d80202, 0x08d80202, + 0x09d80202, 0x0ad80202, 0x0bd80202, 0x0cd80202, 0x0dd80202, 0x0ed80202, 0x0fd80202, 0x10d80202, + 0x11d80202, 0x12d80202, 0x13d80202, 0x14d80202, 0x15d80202, 0x16d80202, 0x17d80202, 0x18d80202, + 0x19d80202, 0x1ad80202, 0x1bd80202, 0x1cd80202, 0x1dd80202, 0x1ed80202, 0x1fd80202, 0x20d80202, + 0x21d80202, 0x22d80202, 0x23d80202, 0x24d80202, 0x25d80202, 0x26d80202, 0x27d80202, 0x28d80202, + 0x29d80202, 0x2ad80202, 0x2bd80202, 0x2cd80202, 0x2dd80202, 0x2ed80202, 0x2fd80202, 0x30d80202, + 0x31d80202, 0x32d80202, 0x33d80202, 0x34d80202, 0x35d80202, 0x36d80202, 0x37d80202, 0x38d80202, + 0x39d80202, 0x3ad80202, 0x3bd80202, 0x3cd80202, 0x3dd80202, 0x3ed80202, 0x3fd80202, 0x40d80202, + 0x41d80202, 0x42d80202, 0x43d80202, 0x44d80202, 0x45d80202, 0x46d80202, 0x47d80202, 0x48d80202, + 0x49d80202, 0x4ad80202, 0x4bd80202, 0x4cd80202, 0x4dd80202, 0x4ed80202, 0x4fd80202, 0x50d80202, + 0x51d80202, 0x52d80202, 0x53d80202, 0x54d80202, 0x55d80202, 0x56d80202, 0x57d80202, 0x58d80202, + 0x59d80202, 0x5ad80202, 0x5bd80202, 0x5cd80202, 0x5dd80202, 0x5ed80202, 0x5fd80202, 0x60d80202, + 0x61d80202, 0x62d80202, 0x63d80202, 0x64d80202, 0x65d80202, 0x66d80202, 0x67d80202, 0x68d80202, + 0x69d80202, 0x6ad80202, 0x6bd80202, 0x6cd80202, 0x6dd80202, 0x6ed80202, 0x6fd80202, 0x70d80202, + 0x71d80202, 0x72d80202, 0x73d80202, 0x74d80202, 0x75d80202, 0x76d80202, 0x77d80202, 0x78d80202, + 0x79d80202, 0x7ad80202, 0x7bd80202, 0x7cd80202, 0x7dd80202, 0x7ed80202, 0x7fd80202, 0x80d80202, + 0x81d80202, 0x82d80202, 0x83d80202, 0x84d80202, 0x85d80202, 0x86d80202, 0x87d80202, 0x88d80202, + 0x89d80202, 0x8ad80202, 0x8bd80202, 0x8cd80202, 0x8dd80202, 0x8ed80202, 0x8fd80202, 0x90d80202, + 0x91d80202, 0x92d80202, 0x93d80202, 0x94d80202, 0x95d80202, 0x96d80202, 0x97d80202, 0x98d80202, + 0x99d80202, 0x9ad80202, 0x9bd80202, 0x9cd80202, 0x9dd80202, 0x9ed80202, 0x9fd80202, 0xa0d80202, + 0xa1d80202, 0xa2d80202, 0xa3d80202, 0xa4d80202, 0xa5d80202, 0xa6d80202, 0xa7d80202, 0xa8d80202, + 0xa9d80202, 0xaad80202, 0xabd80202, 0xacd80202, 0xadd80202, 0xaed80202, 0xafd80202, 0xb0d80202, + 0xb1d80202, 0xb2d80202, 0xb3d80202, 0xb4d80202, 0xb5d80202, 0xb6d80202, 0xb7d80202, 0xb8d80202, + 0xb9d80202, 0xbad80202, 0xbbd80202, 0xbcd80202, 0xbdd80202, 0xbed80202, 0xbfd80202, 0xc0d80202, + 0xc1d80202, 0xc2d80202, 0xc3d80202, 0xc4d80202, 0xc5d80202, 0xc6d80202, 0xc7d80202, 0xc8d80202, + 0xc9d80202, 0xcad80202, 0xcbd80202, 0xccd80202, 0xcdd80202, 0xced80202, 0xcfd80202, 0xd0d80202, + 0xd1d80202, 0xd2d80202, 0xd3d80202, 0xd4d80202, 0xd5d80202, 0xd6d80202, 0xd7d80202, 0xd8d80202, + 0xd9d80202, 0xdad80202, 0xdbd80202, 0xdcd80202, 0xddd80202, 0xded80202, 0xdfd80202, 0xe0d80202, + 0xe1d80202, 0xe2d80202, 0xe3d80202, 0xe4d80202, 0xe5d80202, 0xe6d80202, 0xe7d80202, 0xe8d80202, + 0xe9d80202, 0xead80202, 0xebd80202, 0xecd80202, 0xedd80202, 0xeed80202, 0xefd80202, 0xf0d80202, + 0xf1d80202, 0xf2d80202, 0xf3d80202, 0xf4d80202, 0xf5d80202, 0xf6d80202, 0xf7d80202, 0xf8d80202, + 0xf9d80202, 0xfad80202, 0xfbd80202, 0xfcd80202, 0xfdd80202, 0xfed80202, 0xffd80202, 0x02d90202, + 0x03d90202, 0x04d90202, 0x05d90202, 0x06d90202, 0x07d90202, 0x08d90202, 0x09d90202, 0x0ad90202, + 0x0bd90202, 0x0cd90202, 0x0dd90202, 0x0ed90202, 0x0fd90202, 0x10d90202, 0x11d90202, 0x12d90202, + 0x13d90202, 0x14d90202, 0x15d90202, 0x16d90202, 0x17d90202, 0x18d90202, 0x19d90202, 0x1ad90202, + 0x1bd90202, 0x1cd90202, 0x1dd90202, 0x1ed90202, 0x1fd90202, 0x20d90202, 0x21d90202, 0x22d90202, + 0x23d90202, 0x24d90202, 0x25d90202, 0x26d90202, 0x27d90202, 0x28d90202, 0x29d90202, 0x2ad90202, + 0x2bd90202, 0x2cd90202, 0x2dd90202, 0x2ed90202, 0x2fd90202, 0x30d90202, 0x31d90202, 0x32d90202, + 0x33d90202, 0x34d90202, 0x35d90202, 0x36d90202, 0x37d90202, 0x38d90202, 0x39d90202, 0x3ad90202, + 0x3bd90202, 0x3cd90202, 0x3dd90202, 0x3ed90202, 0x3fd90202, 0x40d90202, 0x41d90202, 0x42d90202, + 0x43d90202, 0x44d90202, 0x45d90202, 0x46d90202, 0x47d90202, 0x48d90202, 0x49d90202, 0x4ad90202, + 0x4bd90202, 0x4cd90202, 0x4dd90202, 0x4ed90202, 0x4fd90202, 0x50d90202, 0x51d90202, 0x52d90202, + 0x53d90202, 0x54d90202, 0x55d90202, 0x56d90202, 0x57d90202, 0x58d90202, 0x59d90202, 0x5ad90202, + 0x5bd90202, 0x5cd90202, 0x5dd90202, 0x5ed90202, 0x5fd90202, 0x60d90202, 0x61d90202, 0x62d90202, + 0x63d90202, 0x64d90202, 0x65d90202, 0x66d90202, 0x67d90202, 0x68d90202, 0x69d90202, 0x6ad90202, + 0x6bd90202, 0x6cd90202, 0x6dd90202, 0x6ed90202, 0x6fd90202, 0x70d90202, 0x71d90202, 0x72d90202, + 0x73d90202, 0x74d90202, 0x75d90202, 0x76d90202, 0x77d90202, 0x78d90202, 0x79d90202, 0x7ad90202, + 0x7bd90202, 0x7cd90202, 0x7dd90202, 0x7ed90202, 0x7fd90202, 0x80d90202, 0x81d90202, 0x82d90202, + 0x83d90202, 0x84d90202, 0x85d90202, 0x86d90202, 0x87d90202, 0x88d90202, 0x89d90202, 0x8ad90202, + 0x8bd90202, 0x8cd90202, 0x8dd90202, 0x8ed90202, 0x8fd90202, 0x90d90202, 0x91d90202, 0x92d90202, + 0x93d90202, 0x94d90202, 0x95d90202, 0x96d90202, 0x97d90202, 0x98d90202, 0x99d90202, 0x9ad90202, + 0x9bd90202, 0x9cd90202, 0x9dd90202, 0x9ed90202, 0x9fd90202, 0xa0d90202, 0xa1d90202, 0xa2d90202, + 0xa3d90202, 0xa4d90202, 0xa5d90202, 0xa6d90202, 0xa7d90202, 0xa8d90202, 0xa9d90202, 0xaad90202, + 0xabd90202, 0xacd90202, 0xadd90202, 0xaed90202, 0xafd90202, 0xb0d90202, 0xb1d90202, 0xb2d90202, + 0xb3d90202, 0xb4d90202, 0xb5d90202, 0xb6d90202, 0xb7d90202, 0xb8d90202, 0xb9d90202, 0xbad90202, + 0xbbd90202, 0xbcd90202, 0xbdd90202, 0xbed90202, 0xbfd90202, 0xc0d90202, 0xc1d90202, 0xc2d90202, + 0xc3d90202, 0xc4d90202, 0xc5d90202, 0xc6d90202, 0xc7d90202, 0xc8d90202, 0xc9d90202, 0xcad90202, + 0xcbd90202, 0xccd90202, 0xcdd90202, 0xced90202, 0xcfd90202, 0xd0d90202, 0xd1d90202, 0xd2d90202, + 0xd3d90202, 0xd4d90202, 0xd5d90202, 0xd6d90202, 0xe5d90202, 0xe6d90202, 0xe7d90202, 0xe8d90202, + 0xe9d90202, 0xead90202, 0xebd90202, 0xecd90202, 0xedd90202, 0xeed90202, 0xefd90202, 0xf0d90202, + 0xf1d90202, 0xf2d90202, 0xf3d90202, 0xf4d90202, 0xf5d90202, 0xf6d90202, 0xf7d90202, 0xf8d90202, + 0xf9d90202, 0xfad90202, 0xfbd90202, 0xfcd90202, 0xfdd90202, 0xfed90202, 0xffd90202, 0x02da0202, + 0x03da0202, 0x04da0202, 0x05da0202, 0x06da0202, 0x07da0202, 0x08da0202, 0x09da0202, 0x0ada0202, + 0x0bda0202, 0x0cda0202, 0x0dda0202, 0x0eda0202, 0x0fda0202, 0x10da0202, 0x11da0202, 0x12da0202, + 0x13da0202, 0x14da0202, 0x15da0202, 0x16da0202, 0x17da0202, 0x18da0202, 0x19da0202, 0x1ada0202, + 0x1bda0202, 0x1cda0202, 0x1dda0202, 0x1eda0202, 0x1fda0202, 0x20da0202, 0x21da0202, 0x22da0202, + 0x23da0202, 0x24da0202, 0x25da0202, 0x26da0202, 0x27da0202, 0x28da0202, 0x29da0202, 0x2ada0202, + 0x2bda0202, 0x2cda0202, 0x2dda0202, 0x2eda0202, 0x2fda0202, 0x30da0202, 0x31da0202, 0x32da0202, + 0x33da0202, 0x34da0202, 0x35da0202, 0x36da0202, 0x37da0202, 0x38da0202, 0x39da0202, 0x3ada0202, + 0x3bda0202, 0x3cda0202, 0x3dda0202, 0x3eda0202, 0x3fda0202, 0x40da0202, 0x41da0202, 0x42da0202, + 0x43da0202, 0x44da0202, 0x45da0202, 0x46da0202, 0x47da0202, 0x48da0202, 0x49da0202, 0x4ada0202, + 0x4bda0202, 0x4cda0202, 0x4dda0202, 0x4eda0202, 0x4fda0202, 0x50da0202, 0x51da0202, 0x52da0202, + 0x53da0202, 0x54da0202, 0x55da0202, 0x56da0202, 0x57da0202, 0x58da0202, 0x59da0202, 0x5ada0202, + 0x5bda0202, 0x5cda0202, 0x5dda0202, 0x5eda0202, 0x5fda0202, 0x60da0202, 0x61da0202, 0x62da0202, + 0x63da0202, 0x64da0202, 0x65da0202, 0x66da0202, 0x67da0202, 0x68da0202, 0x69da0202, 0x6ada0202, + 0x6bda0202, 0x6cda0202, 0x6dda0202, 0x6eda0202, 0x6fda0202, 0x70da0202, 0x71da0202, 0x72da0202, + 0x73da0202, 0x74da0202, 0x75da0202, 0x76da0202, 0x77da0202, 0x78da0202, 0x79da0202, 0x7ada0202, + 0x7bda0202, 0x7cda0202, 0x7dda0202, 0x7eda0202, 0x7fda0202, 0x80da0202, 0x81da0202, 0x82da0202, + 0x83da0202, 0x84da0202, 0x85da0202, 0x86da0202, 0x87da0202, 0x88da0202, 0x89da0202, 0x8ada0202, + 0x8bda0202, 0x8cda0202, 0x8dda0202, 0x8eda0202, 0x8fda0202, 0x90da0202, 0x91da0202, 0x92da0202, + 0x93da0202, 0x94da0202, 0x95da0202, 0x96da0202, 0x97da0202, 0x98da0202, 0x99da0202, 0x9ada0202, + 0x9bda0202, 0x9cda0202, 0x9dda0202, 0x9eda0202, 0x9fda0202, 0xa0da0202, 0xa1da0202, 0xa2da0202, + 0xa3da0202, 0xa4da0202, 0xa5da0202, 0xa6da0202, 0xa7da0202, 0xa8da0202, 0xa9da0202, 0xaada0202, + 0xabda0202, 0xacda0202, 0xadda0202, 0xaeda0202, 0xafda0202, 0xb0da0202, 0xb1da0202, 0xb2da0202, + 0xb3da0202, 0xb4da0202, 0xb5da0202, 0xb6da0202, 0xb7da0202, 0xb8da0202, 0xb9da0202, 0xbada0202, + 0xbbda0202, 0xbcda0202, 0xbdda0202, 0xbeda0202, 0xbfda0202, 0xc0da0202, 0xc1da0202, 0xc2da0202, + 0xc3da0202, 0xc4da0202, 0xc5da0202, 0xc6da0202, 0xc7da0202, 0xc8da0202, 0xc9da0202, 0xcada0202, + 0xcbda0202, 0xccda0202, 0xcdda0202, 0xceda0202, 0xcfda0202, 0xd0da0202, 0xd1da0202, 0xd2da0202, + 0xd3da0202, 0xd4da0202, 0xd5da0202, 0xd6da0202, 0xd7da0202, 0xd8da0202, 0xd9da0202, 0xdada0202, + 0xdbda0202, 0xdcda0202, 0xddda0202, 0xdeda0202, 0xdfda0202, 0xe0da0202, 0xe1da0202, 0xe2da0202, + 0xe3da0202, 0xe4da0202, 0xe5da0202, 0xe6da0202, 0xe7da0202, 0xe8da0202, 0xe9da0202, 0xeada0202, + 0xebda0202, 0xecda0202, 0xedda0202, 0xeeda0202, 0xefda0202, 0xf0da0202, 0xf1da0202, 0xf2da0202, + 0xf3da0202, 0xf4da0202, 0xf5da0202, 0xf6da0202, 0xf7da0202, 0xf8da0202, 0xf9da0202, 0xfada0202, + 0xfbda0202, 0xfcda0202, 0xfdda0202, 0xfeda0202, 0xffda0202, 0x02db0202, 0x03db0202, 0x04db0202, + 0x05db0202, 0x06db0202, 0x07db0202, 0x08db0202, 0x09db0202, 0x0adb0202, 0x0bdb0202, 0x0cdb0202, + 0x0ddb0202, 0x0edb0202, 0x0fdb0202, 0x10db0202, 0x11db0202, 0x12db0202, 0x13db0202, 0x14db0202, + 0x15db0202, 0x16db0202, 0x17db0202, 0x18db0202, 0x19db0202, 0x1adb0202, 0x1bdb0202, 0x1cdb0202, + 0x1ddb0202, 0x1edb0202, 0x1fdb0202, 0x20db0202, 0x21db0202, 0x22db0202, 0x23db0202, 0x24db0202, + 0x25db0202, 0x26db0202, 0x27db0202, 0x28db0202, 0x29db0202, 0x2adb0202, 0x2bdb0202, 0x2cdb0202, + 0x2ddb0202, 0x2edb0202, 0x2fdb0202, 0x30db0202, 0x31db0202, 0x32db0202, 0x33db0202, 0x34db0202, + 0x35db0202, 0x36db0202, 0x37db0202, 0x38db0202, 0x39db0202, 0x3adb0202, 0x3bdb0202, 0x3cdb0202, + 0x3ddb0202, 0x3edb0202, 0x3fdb0202, 0x40db0202, 0x41db0202, 0x42db0202, 0x43db0202, 0x44db0202, + 0x45db0202, 0x46db0202, 0x47db0202, 0x48db0202, 0x49db0202, 0x4adb0202, 0x4bdb0202, 0x4cdb0202, + 0x4ddb0202, 0x4edb0202, 0x4fdb0202, 0x50db0202, 0x51db0202, 0x52db0202, 0x53db0202, 0x54db0202, + 0x55db0202, 0x56db0202, 0x57db0202, 0x58db0202, 0x59db0202, 0x5adb0202, 0x5bdb0202, 0x5cdb0202, + 0x5ddb0202, 0x5edb0202, 0x5fdb0202, 0x60db0202, 0x61db0202, 0x62db0202, 0x63db0202, 0x64db0202, + 0x65db0202, 0x66db0202, 0x67db0202, 0x68db0202, 0x69db0202, 0x6adb0202, 0x6bdb0202, 0x6cdb0202, + 0x6ddb0202, 0x6edb0202, 0x6fdb0202, 0x70db0202, 0x71db0202, 0x72db0202, 0x73db0202, 0x74db0202, + 0x75db0202, 0x76db0202, 0x77db0202, 0x78db0202, 0x79db0202, 0x7adb0202, 0x7bdb0202, 0x7cdb0202, + 0x7ddb0202, 0x7edb0202, 0x7fdb0202, 0x80db0202, 0x81db0202, 0x82db0202, 0x83db0202, 0x84db0202, + 0x85db0202, 0x86db0202, 0x87db0202, 0x88db0202, 0x89db0202, 0x8adb0202, 0x8bdb0202, 0x8cdb0202, + 0x8ddb0202, 0x8edb0202, 0x8fdb0202, 0x90db0202, 0x91db0202, 0x92db0202, 0x93db0202, 0x94db0202, + 0x95db0202, 0x96db0202, 0x97db0202, 0x98db0202, 0x99db0202, 0x9adb0202, 0x9bdb0202, 0x9cdb0202, + 0x9ddb0202, 0x9edb0202, 0x9fdb0202, 0xa0db0202, 0xa1db0202, 0xa2db0202, 0xa3db0202, 0xa4db0202, + 0xa5db0202, 0xa6db0202, 0xa7db0202, 0xa8db0202, 0xa9db0202, 0xaadb0202, 0xabdb0202, 0xacdb0202, + 0xaddb0202, 0xaedb0202, 0xafdb0202, 0xb0db0202, 0xb1db0202, 0xb2db0202, 0xb3db0202, 0xb4db0202, + 0xb5db0202, 0xb6db0202, 0xb7db0202, 0xb8db0202, 0xb9db0202, 0xbadb0202, 0xbbdb0202, 0xbcdb0202, + 0xbddb0202, 0xbedb0202, 0xbfdb0202, 0xc0db0202, 0xc1db0202, 0xc2db0202, 0xc3db0202, 0xc4db0202, + 0xc5db0202, 0xc7db0202, 0xc8db0202, 0xc9db0202, 0xcadb0202, 0xcbdb0202, 0xccdb0202, 0xcddb0202, + 0xcedb0202, 0xcfdb0202, 0xd0db0202, 0xd1db0202, 0xd2db0202, 0xd3db0202, 0xd4db0202, 0xd5db0202, + 0xd6db0202, 0xd7db0202, 0xd8db0202, 0xd9db0202, 0xdadb0202, 0xdbdb0202, 0xdcdb0202, 0xdddb0202, + 0xdedb0202, 0xdfdb0202, 0xe0db0202, 0xe1db0202, 0xe2db0202, 0xe3db0202, 0xe4db0202, 0xe5db0202, + 0xe6db0202, 0xe7db0202, 0xe8db0202, 0xe9db0202, 0xeadb0202, 0xebdb0202, 0xecdb0202, 0xeddb0202, + 0xeedb0202, 0xefdb0202, 0xf0db0202, 0xf1db0202, 0xf2db0202, 0xf3db0202, 0xf4db0202, 0xf5db0202, + 0xf6db0202, 0xf7db0202, 0xf8db0202, 0xf9db0202, 0xfadb0202, 0xfbdb0202, 0xfcdb0202, 0xfddb0202, + 0xfedb0202, 0xffdb0202, 0x02dc0202, 0x03dc0202, 0x04dc0202, 0x05dc0202, 0x06dc0202, 0x07dc0202, + 0x08dc0202, 0x09dc0202, 0x0adc0202, 0x0bdc0202, 0x0cdc0202, 0x0ddc0202, 0x0edc0202, 0x0fdc0202, + 0x10dc0202, 0x11dc0202, 0x12dc0202, 0x13dc0202, 0x14dc0202, 0x15dc0202, 0x16dc0202, 0x17dc0202, + 0x18dc0202, 0x19dc0202, 0x1adc0202, 0x1bdc0202, 0x1cdc0202, 0x1ddc0202, 0x1edc0202, 0x1fdc0202, + 0x20dc0202, 0x21dc0202, 0x22dc0202, 0x23dc0202, 0x24dc0202, 0x25dc0202, 0x26dc0202, 0x27dc0202, + 0x28dc0202, 0x29dc0202, 0x2adc0202, 0x2bdc0202, 0x2cdc0202, 0x2ddc0202, 0x2edc0202, 0x2fdc0202, + 0x30dc0202, 0x31dc0202, 0x32dc0202, 0x33dc0202, 0x34dc0202, 0x35dc0202, 0x36dc0202, 0x37dc0202, + 0x49dc0202, 0x4adc0202, 0x4bdc0202, 0x4cdc0202, 0x4ddc0202, 0x4edc0202, 0x4fdc0202, 0x50dc0202, + 0x51dc0202, 0x52dc0202, 0x53dc0202, 0x54dc0202, 0x55dc0202, 0x56dc0202, 0x57dc0202, 0x58dc0202, + 0x59dc0202, 0x5adc0202, 0x5bdc0202, 0x5cdc0202, 0x5ddc0202, 0x5edc0202, 0x5fdc0202, 0x60dc0202, + 0x61dc0202, 0x62dc0202, 0x63dc0202, 0x64dc0202, 0x65dc0202, 0x66dc0202, 0x67dc0202, 0x68dc0202, + 0x69dc0202, 0x6adc0202, 0x6bdc0202, 0x6cdc0202, 0x6ddc0202, 0x6edc0202, 0x6fdc0202, 0x70dc0202, + 0x71dc0202, 0x72dc0202, 0x73dc0202, 0x74dc0202, 0x75dc0202, 0x76dc0202, 0x77dc0202, 0x78dc0202, + 0x79dc0202, 0x7adc0202, 0x7bdc0202, 0x7cdc0202, 0x7ddc0202, 0x7edc0202, 0x7fdc0202, 0x80dc0202, + 0x81dc0202, 0x82dc0202, 0x83dc0202, 0x84dc0202, 0x85dc0202, 0x86dc0202, 0x87dc0202, 0x88dc0202, + 0x89dc0202, 0x8adc0202, 0x8bdc0202, 0x8cdc0202, 0x8ddc0202, 0x8edc0202, 0x8fdc0202, 0x90dc0202, + 0x91dc0202, 0x92dc0202, 0x93dc0202, 0x94dc0202, 0x95dc0202, 0x96dc0202, 0x97dc0202, 0x98dc0202, + 0x99dc0202, 0x9adc0202, 0x9bdc0202, 0x9cdc0202, 0x9ddc0202, 0x9edc0202, 0x9fdc0202, 0xa0dc0202, + 0xa1dc0202, 0xa2dc0202, 0xa3dc0202, 0xa4dc0202, 0xa5dc0202, 0xa6dc0202, 0xa7dc0202, 0xa8dc0202, + 0xa9dc0202, 0xaadc0202, 0xabdc0202, 0xacdc0202, 0xaddc0202, 0xaedc0202, 0xafdc0202, 0xb0dc0202, + 0xb1dc0202, 0xb2dc0202, 0xb3dc0202, 0xb4dc0202, 0xb5dc0202, 0xb6dc0202, 0xb7dc0202, 0xb8dc0202, + 0xb9dc0202, 0xbadc0202, 0xbbdc0202, 0xbcdc0202, 0xbddc0202, 0xbfdc0202, 0xc0dc0202, 0xc1dc0202, + 0xc2dc0202, 0xc3dc0202, 0xc4dc0202, 0xc5dc0202, 0xc6dc0202, 0xc7dc0202, 0xc8dc0202, 0xc9dc0202, + 0xcadc0202, 0xcbdc0202, 0xccdc0202, 0xcddc0202, 0xcedc0202, 0xcfdc0202, 0xd0dc0202, 0xd1dc0202, + 0xd2dc0202, 0xd3dc0202, 0xd4dc0202, 0xd5dc0202, 0xd6dc0202, 0xd8dc0202, 0xd9dc0202, 0xdadc0202, + 0xdbdc0202, 0xdcdc0202, 0xdddc0202, 0xdedc0202, 0xdfdc0202, 0xe0dc0202, 0xe1dc0202, 0xe2dc0202, + 0xe3dc0202, 0xe4dc0202, 0xe5dc0202, 0xe6dc0202, 0xe7dc0202, 0xe8dc0202, 0xe9dc0202, 0xeadc0202, + 0xebdc0202, 0xecdc0202, 0xeddc0202, 0xeedc0202, 0xefdc0202, 0xf0dc0202, 0xf1dc0202, 0xf2dc0202, + 0xf3dc0202, 0xf4dc0202, 0xf5dc0202, 0xf6dc0202, 0xf7dc0202, 0xf8dc0202, 0xf9dc0202, 0xfadc0202, + 0xfbdc0202, 0xfcdc0202, 0xfddc0202, 0xfedc0202, 0xffdc0202, 0x02dd0202, 0x03dd0202, 0x04dd0202, + 0x05dd0202, 0x06dd0202, 0x07dd0202, 0x08dd0202, 0x09dd0202, 0x0add0202, 0x0bdd0202, 0x0cdd0202, + 0x0ddd0202, 0x0edd0202, 0x0fdd0202, 0x10dd0202, 0x11dd0202, 0x12dd0202, 0x13dd0202, 0x14dd0202, + 0x15dd0202, 0x16dd0202, 0x17dd0202, 0x18dd0202, 0x19dd0202, 0x1add0202, 0x1bdd0202, 0x1cdd0202, + 0x1ddd0202, 0x1edd0202, 0x1fdd0202, 0x20dd0202, 0x21dd0202, 0x22dd0202, 0x23dd0202, 0x24dd0202, + 0x25dd0202, 0x26dd0202, 0x27dd0202, 0x28dd0202, 0x29dd0202, 0x2add0202, 0x2bdd0202, 0x2cdd0202, + 0x2ddd0202, 0x2fdd0202, 0x30dd0202, 0x31dd0202, 0x32dd0202, 0x33dd0202, 0x34dd0202, 0x35dd0202, + 0x36dd0202, 0x37dd0202, 0x38dd0202, 0x39dd0202, 0x3add0202, 0x3bdd0202, 0x3cdd0202, 0x3ddd0202, + 0x3edd0202, 0x3fdd0202, 0x40dd0202, 0x41dd0202, 0x42dd0202, 0x43dd0202, 0x44dd0202, 0x45dd0202, + 0x46dd0202, 0x47dd0202, 0x48dd0202, 0x49dd0202, 0x4add0202, 0x4bdd0202, 0x4cdd0202, 0x4ddd0202, + 0x4edd0202, 0x4fdd0202, 0x50dd0202, 0x51dd0202, 0x52dd0202, 0x53dd0202, 0x54dd0202, 0x55dd0202, + 0x56dd0202, 0x57dd0202, 0x58dd0202, 0x59dd0202, 0x5add0202, 0x5bdd0202, 0x5cdd0202, 0x5ddd0202, + 0x5edd0202, 0x5fdd0202, 0x60dd0202, 0x61dd0202, 0x62dd0202, 0x63dd0202, 0x64dd0202, 0x65dd0202, + 0x66dd0202, 0x67dd0202, 0x68dd0202, 0x69dd0202, 0x6add0202, 0x6bdd0202, 0x6cdd0202, 0x6ddd0202, + 0x6edd0202, 0x6fdd0202, 0x70dd0202, 0x71dd0202, 0x72dd0202, 0x73dd0202, 0x74dd0202, 0x75dd0202, + 0x76dd0202, 0x77dd0202, 0x78dd0202, 0x79dd0202, 0x7add0202, 0x7bdd0202, 0x7cdd0202, 0x7ddd0202, + 0x7edd0202, 0x7fdd0202, 0x80dd0202, 0x81dd0202, 0x82dd0202, 0x83dd0202, 0x84dd0202, 0x85dd0202, + 0x86dd0202, 0x87dd0202, 0x88dd0202, 0x89dd0202, 0x8add0202, 0x8bdd0202, 0x8cdd0202, 0x8ddd0202, + 0x8edd0202, 0x8fdd0202, 0x90dd0202, 0x91dd0202, 0x92dd0202, 0x93dd0202, 0x94dd0202, 0x95dd0202, + 0x96dd0202, 0x97dd0202, 0x98dd0202, 0x99dd0202, 0x9add0202, 0x9bdd0202, 0x9cdd0202, 0x9ddd0202, + 0x9edd0202, 0x9fdd0202, 0xa0dd0202, 0xa1dd0202, 0xa2dd0202, 0xa3dd0202, 0xa4dd0202, 0xa5dd0202, + 0xa6dd0202, 0xa7dd0202, 0xa8dd0202, 0xa9dd0202, 0xaadd0202, 0xabdd0202, 0xacdd0202, 0xaddd0202, + 0xaedd0202, 0xafdd0202, 0xb0dd0202, 0xb1dd0202, 0xb2dd0202, 0xb3dd0202, 0xb4dd0202, 0xb5dd0202, + 0xb6dd0202, 0xb7dd0202, 0xb8dd0202, 0xb9dd0202, 0xbadd0202, 0xbddd0202, 0xbedd0202, 0xbfdd0202, + 0xc0dd0202, 0xc1dd0202, 0xc2dd0202, 0xc3dd0202, 0xc4dd0202, 0xc5dd0202, 0xc6dd0202, 0xc7dd0202, + 0xc8dd0202, 0xc9dd0202, 0xcadd0202, 0xcbdd0202, 0xccdd0202, 0xcddd0202, 0xcedd0202, 0xcfdd0202, + 0xd0dd0202, 0xd1dd0202, 0xd2dd0202, 0xd3dd0202, 0xd4dd0202, 0xd5dd0202, 0xd6dd0202, 0xd7dd0202, + 0xd8dd0202, 0xd9dd0202, 0xdadd0202, 0xdbdd0202, 0xdcdd0202, 0xdddd0202, 0xdedd0202, 0xdfdd0202, + 0xe0dd0202, 0xe1dd0202, 0xe2dd0202, 0xe3dd0202, 0xe4dd0202, 0xe5dd0202, 0xe6dd0202, 0xe7dd0202, + 0xe8dd0202, 0xe9dd0202, 0xeadd0202, 0xebdd0202, 0xecdd0202, 0xeddd0202, 0xeedd0202, 0xefdd0202, + 0xf0dd0202, 0xf1dd0202, 0xf2dd0202, 0xf3dd0202, 0xf4dd0202, 0xf5dd0202, 0xf6dd0202, 0xf7dd0202, + 0xf8dd0202, 0xf9dd0202, 0xfadd0202, 0xfbdd0202, 0xfcdd0202, 0xfddd0202, 0xfedd0202, 0xffdd0202, + 0x02de0202, 0x03de0202, 0x04de0202, 0x05de0202, 0x06de0202, 0x07de0202, 0x08de0202, 0x09de0202, + 0x0ade0202, 0x0bde0202, 0x0cde0202, 0x0dde0202, 0x0ede0202, 0x0fde0202, 0x10de0202, 0x11de0202, + 0x12de0202, 0x13de0202, 0x14de0202, 0x15de0202, 0x16de0202, 0x17de0202, 0x18de0202, 0x19de0202, + 0x1ade0202, 0x1bde0202, 0x1cde0202, 0x1dde0202, 0x1ede0202, 0x1fde0202, 0x20de0202, 0x21de0202, + 0x22de0202, 0x23de0202, 0x24de0202, 0x25de0202, 0x26de0202, 0x27de0202, 0x28de0202, 0x29de0202, + 0x2ade0202, 0x2bde0202, 0x2cde0202, 0x2dde0202, 0x2ede0202, 0x2fde0202, 0x30de0202, 0x31de0202, + 0x32de0202, 0x33de0202, 0x34de0202, 0x35de0202, 0x36de0202, 0x37de0202, 0x38de0202, 0x39de0202, + 0x3ade0202, 0x3bde0202, 0x3cde0202, 0x3dde0202, 0x3ede0202, 0x3fde0202, 0x40de0202, 0x41de0202, + 0x42de0202, 0x43de0202, 0x44de0202, 0x45de0202, 0x46de0202, 0x47de0202, 0x48de0202, 0x49de0202, + 0x4ade0202, 0x4bde0202, 0x4cde0202, 0x4dde0202, 0x4ede0202, 0x4fde0202, 0x50de0202, 0x51de0202, + 0x52de0202, 0x53de0202, 0x54de0202, 0x55de0202, 0x56de0202, 0x57de0202, 0x58de0202, 0x59de0202, + 0x5ade0202, 0x5bde0202, 0x5cde0202, 0x5dde0202, 0x5ede0202, 0x5fde0202, 0x60de0202, 0x61de0202, + 0x62de0202, 0x63de0202, 0x64de0202, 0x65de0202, 0x66de0202, 0x67de0202, 0x68de0202, 0x69de0202, + 0x6ade0202, 0x6bde0202, 0x6cde0202, 0x6dde0202, 0x6ede0202, 0x6fde0202, 0x70de0202, 0x71de0202, + 0x72de0202, 0x73de0202, 0x74de0202, 0x75de0202, 0x76de0202, 0x77de0202, 0x78de0202, 0x79de0202, + 0x7ade0202, 0x7bde0202, 0x7cde0202, 0x7dde0202, 0x7ede0202, 0x7fde0202, 0x80de0202, 0x81de0202, + 0x82de0202, 0x83de0202, 0x84de0202, 0x85de0202, 0x86de0202, 0x87de0202, 0x88de0202, 0x89de0202, + 0x8ade0202, 0x8bde0202, 0x8cde0202, 0x8dde0202, 0x8ede0202, 0x8fde0202, 0x90de0202, 0x91de0202, + 0x92de0202, 0x93de0202, 0x94de0202, 0x95de0202, 0x96de0202, 0x97de0202, 0x98de0202, 0x99de0202, + 0x9ade0202, 0x9bde0202, 0x9cde0202, 0x9dde0202, 0xa0de0202, 0xa1de0202, 0xa2de0202, 0xa3de0202, + 0xa4de0202, 0xa5de0202, 0xa6de0202, 0xa7de0202, 0xa8de0202, 0xa9de0202, 0xaade0202, 0xabde0202, + 0xacde0202, 0xadde0202, 0xaede0202, 0xafde0202, 0xb0de0202, 0xb1de0202, 0xb2de0202, 0xb3de0202, + 0xb4de0202, 0xb5de0202, 0xb6de0202, 0xb7de0202, 0xb8de0202, 0xb9de0202, 0xbade0202, 0xbbde0202, + 0xbcde0202, 0xbdde0202, 0xbede0202, 0xbfde0202, 0xc0de0202, 0xc1de0202, 0xc2de0202, 0xc3de0202, + 0xc4de0202, 0xc5de0202, 0xc6de0202, 0xc7de0202, 0xc8de0202, 0xc9de0202, 0xcade0202, 0xcbde0202, + 0xccde0202, 0xcdde0202, 0xcede0202, 0xcfde0202, 0xd0de0202, 0xd1de0202, 0xd2de0202, 0xd3de0202, + 0xd4de0202, 0xd5de0202, 0xd6de0202, 0xd7de0202, 0xd8de0202, 0xd9de0202, 0xdade0202, 0xdbde0202, + 0xdcde0202, 0xddde0202, 0xdede0202, 0xdfde0202, 0xe0de0202, 0xe1de0202, 0xe2de0202, 0xe3de0202, + 0xe4de0202, 0xe5de0202, 0xe6de0202, 0xe7de0202, 0xe8de0202, 0xe9de0202, 0xeade0202, 0xebde0202, + 0xecde0202, 0xedde0202, 0xeede0202, 0xefde0202, 0xf0de0202, 0xf1de0202, 0xf2de0202, 0xf3de0202, + 0xf4de0202, 0xf5de0202, 0xf6de0202, 0xf7de0202, 0xf8de0202, 0xf9de0202, 0xfade0202, 0xfbde0202, + 0xfcde0202, 0xfdde0202, 0xfede0202, 0xffde0202, 0x02df0202, 0x03df0202, 0x04df0202, 0x05df0202, + 0x06df0202, 0x07df0202, 0x08df0202, 0x09df0202, 0x0adf0202, 0x0bdf0202, 0x0cdf0202, 0x0ddf0202, + 0x0edf0202, 0x0fdf0202, 0x10df0202, 0x11df0202, 0x12df0202, 0x13df0202, 0x14df0202, 0x15df0202, + 0x16df0202, 0x17df0202, 0x18df0202, 0x19df0202, 0x1adf0202, 0x1bdf0202, 0x1cdf0202, 0x1ddf0202, + 0x1edf0202, 0x1fdf0202, 0x20df0202, 0x21df0202, 0x22df0202, 0x23df0202, 0x24df0202, 0x25df0202, + 0x26df0202, 0x27df0202, 0x28df0202, 0x29df0202, 0x2adf0202, 0x2bdf0202, 0x2cdf0202, 0x2ddf0202, + 0x2edf0202, 0x2fdf0202, 0x30df0202, 0x31df0202, 0x32df0202, 0x33df0202, 0x34df0202, 0x35df0202, + 0x36df0202, 0x37df0202, 0x38df0202, 0x39df0202, 0x3adf0202, 0x3bdf0202, 0x3cdf0202, 0x3ddf0202, + 0x3edf0202, 0x3fdf0202, 0x40df0202, 0x41df0202, 0x42df0202, 0x43df0202, 0x44df0202, 0x45df0202, + 0x46df0202, 0x47df0202, 0x48df0202, 0x49df0202, 0x4adf0202, 0x4bdf0202, 0x4cdf0202, 0x4ddf0202, + 0x4edf0202, 0x4fdf0202, 0x50df0202, 0x51df0202, 0x52df0202, 0x53df0202, 0x54df0202, 0x55df0202, + 0x56df0202, 0x57df0202, 0x58df0202, 0x59df0202, 0x5adf0202, 0x5bdf0202, 0x5cdf0202, 0x5ddf0202, + 0x5edf0202, 0x5fdf0202, 0x60df0202, 0x61df0202, 0x62df0202, 0x63df0202, 0x64df0202, 0x65df0202, + 0x66df0202, 0x67df0202, 0x68df0202, 0x69df0202, 0x6adf0202, 0x6bdf0202, 0x6cdf0202, 0x6ddf0202, + 0x6edf0202, 0x6fdf0202, 0x70df0202, 0x71df0202, 0x72df0202, 0x73df0202, 0x74df0202, 0x75df0202, + 0x76df0202, 0x77df0202, 0x78df0202, 0x79df0202, 0x7adf0202, 0x7bdf0202, 0x7cdf0202, 0x7ddf0202, + 0x7edf0202, 0x7fdf0202, 0x80df0202, 0x81df0202, 0x82df0202, 0x83df0202, 0x84df0202, 0x85df0202, + 0x86df0202, 0x87df0202, 0x88df0202, 0x89df0202, 0x8adf0202, 0x8bdf0202, 0x8cdf0202, 0x8ddf0202, + 0x8edf0202, 0x8fdf0202, 0x90df0202, 0x91df0202, 0x92df0202, 0x93df0202, 0x94df0202, 0x95df0202, + 0x96df0202, 0x97df0202, 0x98df0202, 0x99df0202, 0x9adf0202, 0x9bdf0202, 0x9cdf0202, 0x9ddf0202, + 0x9edf0202, 0x9fdf0202, 0xa0df0202, 0xa1df0202, 0xa2df0202, 0xa3df0202, 0xa4df0202, 0xa5df0202, + 0xa6df0202, 0xa7df0202, 0xa8df0202, 0xa9df0202, 0xaadf0202, 0xabdf0202, 0xacdf0202, 0xaddf0202, + 0xaedf0202, 0xafdf0202, 0xb0df0202, 0xb1df0202, 0xb2df0202, 0xb3df0202, 0xb4df0202, 0xb5df0202, + 0xb6df0202, 0xb7df0202, 0xb8df0202, 0xb9df0202, 0xbadf0202, 0xbbdf0202, 0xbcdf0202, 0xbddf0202, + 0xbedf0202, 0xbfdf0202, 0xc0df0202, 0xc1df0202, 0xc2df0202, 0xc3df0202, 0xc4df0202, 0xc5df0202, + 0xc6df0202, 0xc7df0202, 0xc8df0202, 0xc9df0202, 0xcadf0202, 0xcbdf0202, 0xccdf0202, 0xcddf0202, + 0xcedf0202, 0xcfdf0202, 0xd0df0202, 0xd1df0202, 0xd2df0202, 0xd3df0202, 0xd4df0202, 0xd5df0202, + 0xd6df0202, 0xd7df0202, 0xd8df0202, 0xd9df0202, 0xdadf0202, 0xdbdf0202, 0xdcdf0202, 0xdddf0202, + 0xdedf0202, 0xdfdf0202, 0xe0df0202, 0xe1df0202, 0xe2df0202, 0xe3df0202, 0xe4df0202, 0xe5df0202, + 0xe6df0202, 0xe7df0202, 0xe8df0202, 0xe9df0202, 0xeadf0202, 0xebdf0202, 0xecdf0202, 0xeddf0202, + 0xeedf0202, 0xefdf0202, 0xf0df0202, 0xf1df0202, 0xf2df0202, 0xf3df0202, 0xf4df0202, 0xf5df0202, + 0xf6df0202, 0xf7df0202, 0xf8df0202, 0xf9df0202, 0xfadf0202, 0xfbdf0202, 0xfcdf0202, 0xfddf0202, + 0xfedf0202, 0xffdf0202, 0x02e00202, 0x03e00202, 0x04e00202, 0x05e00202, 0x06e00202, 0x07e00202, + 0x08e00202, 0x09e00202, 0x0ae00202, 0x0be00202, 0x0ce00202, 0x0de00202, 0x0ee00202, 0x0fe00202, + 0x10e00202, 0x11e00202, 0x12e00202, 0x13e00202, 0x14e00202, 0x15e00202, 0x16e00202, 0x17e00202, + 0x18e00202, 0x19e00202, 0x1ae00202, 0x1be00202, 0x1ce00202, 0x1de00202, 0x1ee00202, 0x1fe00202, + 0x20e00202, 0x21e00202, 0x22e00202, 0x23e00202, 0x24e00202, 0x25e00202, 0x26e00202, 0x27e00202, + 0x28e00202, 0x29e00202, 0x2ae00202, 0x2be00202, 0x2ce00202, 0x2de00202, 0x2ee00202, 0x2fe00202, + 0x30e00202, 0x31e00202, 0x32e00202, 0x33e00202, 0x34e00202, 0x35e00202, 0x36e00202, 0x37e00202, + 0x38e00202, 0x39e00202, 0x3ae00202, 0x3be00202, 0x3ce00202, 0x3de00202, 0x3ee00202, 0x3fe00202, + 0x40e00202, 0x41e00202, 0x42e00202, 0x43e00202, 0x44e00202, 0x45e00202, 0x46e00202, 0x47e00202, + 0x48e00202, 0x49e00202, 0x4ae00202, 0x4be00202, 0x4ce00202, 0x4de00202, 0x4ee00202, 0x4fe00202, + 0x50e00202, 0x51e00202, 0x52e00202, 0x53e00202, 0x54e00202, 0x55e00202, 0x56e00202, 0x57e00202, + 0x58e00202, 0x59e00202, 0x5ae00202, 0x5be00202, 0x5ce00202, 0x5de00202, 0x5ee00202, 0x5fe00202, + 0x60e00202, 0x61e00202, 0x62e00202, 0x63e00202, 0x64e00202, 0x65e00202, 0x66e00202, 0x67e00202, + 0x68e00202, 0x69e00202, 0x6ae00202, 0x6be00202, 0x6ce00202, 0x6de00202, 0x6ee00202, 0x6fe00202, + 0x70e00202, 0x71e00202, 0x72e00202, 0x73e00202, 0x74e00202, 0x75e00202, 0x76e00202, 0x77e00202, + 0x78e00202, 0x79e00202, 0x7ae00202, 0x7be00202, 0x7ce00202, 0x7de00202, 0x7ee00202, 0x7fe00202, + 0x80e00202, 0x81e00202, 0x82e00202, 0x83e00202, 0x84e00202, 0x85e00202, 0x86e00202, 0x87e00202, + 0x88e00202, 0x89e00202, 0x8ae00202, 0x8be00202, 0x8ce00202, 0x8de00202, 0x8ee00202, 0x8fe00202, + 0x90e00202, 0x91e00202, 0x92e00202, 0x93e00202, 0x94e00202, 0x95e00202, 0x96e00202, 0x97e00202, + 0x98e00202, 0x99e00202, 0x9ae00202, 0x9be00202, 0x9ce00202, 0x9de00202, 0x9ee00202, 0x9fe00202, + 0xa0e00202, 0xa1e00202, 0xa2e00202, 0xa3e00202, 0xa4e00202, 0xa5e00202, 0xa6e00202, 0xa7e00202, + 0xa8e00202, 0xa9e00202, 0xaae00202, 0xabe00202, 0xace00202, 0xade00202, 0xaee00202, 0xafe00202, + 0xb0e00202, 0xb1e00202, 0xb2e00202, 0xb3e00202, 0xb4e00202, 0xb5e00202, 0xb6e00202, 0xb7e00202, + 0xb8e00202, 0xb9e00202, 0xbae00202, 0xbbe00202, 0xbce00202, 0xbde00202, 0xbee00202, 0xbfe00202, + 0xc0e00202, 0xc1e00202, 0xc2e00202, 0xc3e00202, 0xc4e00202, 0xc5e00202, 0xc6e00202, 0xc7e00202, + 0xc8e00202, 0xc9e00202, 0xcae00202, 0xcbe00202, 0xcce00202, 0xcde00202, 0xcee00202, 0xcfe00202, + 0xd0e00202, 0xd1e00202, 0xd2e00202, 0xd3e00202, 0xd4e00202, 0xd5e00202, 0xd6e00202, 0xd7e00202, + 0xd8e00202, 0xd9e00202, 0xdae00202, 0xdbe00202, 0xdce00202, 0xdde00202, 0xdee00202, 0xdfe00202, + 0xe0e00202, 0xe1e00202, 0xe2e00202, 0xe3e00202, 0xe4e00202, 0xe5e00202, 0xe6e00202, 0xe7e00202, + 0xe8e00202, 0xe9e00202, 0xeae00202, 0xebe00202, 0xece00202, 0xede00202, 0xeee00202, 0xefe00202, + 0xf5e00202, 0xf6e00202, 0xf7e00202, 0xf8e00202, 0xf9e00202, 0xfae00202, 0xfbe00202, 0xfce00202, + 0xfde00202, 0xfee00202, 0xffe00202, 0x02e10202, 0x03e10202, 0x04e10202, 0x05e10202, 0x06e10202, + 0x07e10202, 0x08e10202, 0x09e10202, 0x0ae10202, 0x0be10202, 0x0ce10202, 0x0de10202, 0x0ee10202, + 0x0fe10202, 0x10e10202, 0x11e10202, 0x12e10202, 0x13e10202, 0x14e10202, 0x15e10202, 0x16e10202, + 0x17e10202, 0x18e10202, 0x19e10202, 0x1ae10202, 0x1be10202, 0x1ce10202, 0x1de10202, 0x1ee10202, + 0x1fe10202, 0x20e10202, 0x21e10202, 0x22e10202, 0x23e10202, 0x24e10202, 0x25e10202, 0x26e10202, + 0x27e10202, 0x28e10202, 0x29e10202, 0x2ae10202, 0x2be10202, 0x2ce10202, 0x2de10202, 0x2ee10202, + 0x2fe10202, 0x30e10202, 0x31e10202, 0x32e10202, 0x33e10202, 0x34e10202, 0x35e10202, 0x36e10202, + 0x37e10202, 0x38e10202, 0x39e10202, 0x3ae10202, 0x3be10202, 0x3ce10202, 0x3de10202, 0x3ee10202, + 0x3fe10202, 0x40e10202, 0x41e10202, 0x42e10202, 0x43e10202, 0x44e10202, 0x45e10202, 0x46e10202, + 0x47e10202, 0x48e10202, 0x49e10202, 0x4ae10202, 0x4be10202, 0x4ce10202, 0x4de10202, 0x4ee10202, + 0x4fe10202, 0x50e10202, 0x51e10202, 0x52e10202, 0x53e10202, 0x54e10202, 0x55e10202, 0x56e10202, + 0x57e10202, 0x58e10202, 0x59e10202, 0x5ae10202, 0x5be10202, 0x5ce10202, 0x5de10202, 0x5ee10202, + 0x5fe10202, 0x60e10202, 0x61e10202, 0x62e10202, 0x63e10202, 0x64e10202, 0x65e10202, 0x66e10202, + 0x67e10202, 0x69e10202, 0x6ae10202, 0x6be10202, 0x6ce10202, 0x6de10202, 0x6ee10202, 0x6fe10202, + 0x70e10202, 0x71e10202, 0x72e10202, 0x73e10202, 0x74e10202, 0x75e10202, 0x76e10202, 0x77e10202, + 0x78e10202, 0x79e10202, 0x7ae10202, 0x7be10202, 0x7ce10202, 0x7de10202, 0x7ee10202, 0x7fe10202, + 0x80e10202, 0x81e10202, 0x82e10202, 0x83e10202, 0x84e10202, 0x85e10202, 0x86e10202, 0x87e10202, + 0x88e10202, 0x89e10202, 0x8ae10202, 0x8be10202, 0x8ce10202, 0x8de10202, 0x8ee10202, 0x8fe10202, + 0x90e10202, 0x91e10202, 0x92e10202, 0x93e10202, 0x94e10202, 0x95e10202, 0x96e10202, 0x97e10202, + 0x98e10202, 0x99e10202, 0x9ae10202, 0x9be10202, 0x9ce10202, 0x9de10202, 0x9ee10202, 0x9fe10202, + 0xa0e10202, 0xa1e10202, 0xa2e10202, 0xa3e10202, 0xa4e10202, 0xa5e10202, 0xa6e10202, 0xa7e10202, + 0xa8e10202, 0xa9e10202, 0xaae10202, 0xabe10202, 0xace10202, 0xade10202, 0xaee10202, 0xafe10202, + 0xb0e10202, 0xb1e10202, 0xb2e10202, 0xb3e10202, 0xb4e10202, 0xb5e10202, 0xb6e10202, 0xb7e10202, + 0xb8e10202, 0xb9e10202, 0xbae10202, 0xbbe10202, 0xbce10202, 0xbde10202, 0xbee10202, 0xbfe10202, + 0xc0e10202, 0xc1e10202, 0xc2e10202, 0xc3e10202, 0xc4e10202, 0xc5e10202, 0xc6e10202, 0xc7e10202, + 0xc8e10202, 0xc9e10202, 0xcae10202, 0xcbe10202, 0xcce10202, 0xcde10202, 0xcee10202, 0xcfe10202, + 0xd0e10202, 0xd1e10202, 0xd2e10202, 0xd3e10202, 0xd4e10202, 0xd5e10202, 0xd6e10202, 0xd7e10202, + 0xd8e10202, 0xd9e10202, 0xdae10202, 0xdbe10202, 0xdce10202, 0xdde10202, 0xdee10202, 0xdfe10202, + 0xe0e10202, 0xe1e10202, 0xe2e10202, 0xe3e10202, 0xe4e10202, 0xe5e10202, 0xe6e10202, 0xe7e10202, + 0xe8e10202, 0xe9e10202, 0xeae10202, 0xebe10202, 0xece10202, 0xede10202, 0xeee10202, 0xefe10202, + 0xf0e10202, 0xf1e10202, 0xf2e10202, 0xf3e10202, 0xf4e10202, 0xf5e10202, 0xf6e10202, 0xf7e10202, + 0xf8e10202, 0xf9e10202, 0xfae10202, 0xfbe10202, 0xfce10202, 0xfde10202, 0xfee10202, 0xffe10202, + 0x02e20202, 0x03e20202, 0x04e20202, 0x05e20202, 0x06e20202, 0x07e20202, 0x08e20202, 0x09e20202, + 0x0ae20202, 0x0be20202, 0x0ce20202, 0x0de20202, 0x0ee20202, 0x0fe20202, 0x10e20202, 0x11e20202, + 0x12e20202, 0x13e20202, 0x14e20202, 0x15e20202, 0x16e20202, 0x17e20202, 0x18e20202, 0x19e20202, + 0x1ae20202, 0x1be20202, 0x1ce20202, 0x1de20202, 0x1ee20202, 0x1fe20202, 0x20e20202, 0x21e20202, + 0x22e20202, 0x23e20202, 0x24e20202, 0x25e20202, 0x26e20202, 0x27e20202, 0x28e20202, 0x29e20202, + 0x2ae20202, 0x2be20202, 0x2ce20202, 0x2de20202, 0x2ee20202, 0x2fe20202, 0x30e20202, 0x31e20202, + 0x32e20202, 0x33e20202, 0x34e20202, 0x35e20202, 0x36e20202, 0x37e20202, 0x38e20202, 0x39e20202, + 0x3ae20202, 0x3be20202, 0x3ce20202, 0x3de20202, 0x3ee20202, 0x3fe20202, 0x40e20202, 0x41e20202, + 0x42e20202, 0x43e20202, 0x44e20202, 0x45e20202, 0x46e20202, 0x47e20202, 0x48e20202, 0x49e20202, + 0x4ae20202, 0x4be20202, 0x4ce20202, 0x4de20202, 0x4ee20202, 0x4fe20202, 0x50e20202, 0x51e20202, + 0x52e20202, 0x53e20202, 0x54e20202, 0x55e20202, 0x56e20202, 0x57e20202, 0x58e20202, 0x59e20202, + 0x5ae20202, 0x5be20202, 0x5ce20202, 0x5de20202, 0x5ee20202, 0x5fe20202, 0x60e20202, 0x61e20202, + 0x62e20202, 0x63e20202, 0x64e20202, 0x65e20202, 0x66e20202, 0x67e20202, 0x68e20202, 0x69e20202, + 0x6ae20202, 0x6be20202, 0x6ce20202, 0x6de20202, 0x6ee20202, 0x6fe20202, 0x70e20202, 0x71e20202, + 0x72e20202, 0x73e20202, 0x74e20202, 0x75e20202, 0x76e20202, 0x77e20202, 0x78e20202, 0x79e20202, + 0x7ae20202, 0x7be20202, 0x7ce20202, 0x7de20202, 0x7ee20202, 0x7fe20202, 0x80e20202, 0x81e20202, + 0x82e20202, 0x83e20202, 0x84e20202, 0x85e20202, 0x86e20202, 0x87e20202, 0x88e20202, 0x89e20202, + 0x8ae20202, 0x8be20202, 0x8ce20202, 0x8de20202, 0x8ee20202, 0x8fe20202, 0x90e20202, 0x91e20202, + 0x92e20202, 0x93e20202, 0x94e20202, 0x95e20202, 0x96e20202, 0x97e20202, 0x98e20202, 0x99e20202, + 0x9ae20202, 0x9be20202, 0x9ce20202, 0x9de20202, 0x9ee20202, 0x9fe20202, 0xa0e20202, 0xa1e20202, + 0xa2e20202, 0xa3e20202, 0xa4e20202, 0xa5e20202, 0xa6e20202, 0xa7e20202, 0xa8e20202, 0xa9e20202, + 0xaae20202, 0xabe20202, 0xace20202, 0xade20202, 0xaee20202, 0xafe20202, 0xb0e20202, 0xb1e20202, + 0xb2e20202, 0xb3e20202, 0xb4e20202, 0xb5e20202, 0xb6e20202, 0xb7e20202, 0xb8e20202, 0xb9e20202, + 0xbae20202, 0xbbe20202, 0xbce20202, 0xbde20202, 0xbee20202, 0xbfe20202, 0xc0e20202, 0xc1e20202, + 0xc2e20202, 0xc3e20202, 0xc4e20202, 0xc5e20202, 0xc6e20202, 0xc7e20202, 0xc8e20202, 0xc9e20202, + 0xcae20202, 0xcbe20202, 0xcce20202, 0xcde20202, 0xcee20202, 0xcfe20202, 0xd0e20202, 0xd1e20202, + 0xd2e20202, 0xd3e20202, 0xd4e20202, 0xd5e20202, 0xd6e20202, 0xd7e20202, 0xd8e20202, 0xd9e20202, + 0xdae20202, 0xdbe20202, 0xdce20202, 0xdde20202, 0xdee20202, 0xdfe20202, 0xe0e20202, 0xe1e20202, + 0xe2e20202, 0xe3e20202, 0xe4e20202, 0xe5e20202, 0xe6e20202, 0xe7e20202, 0xe8e20202, 0xe9e20202, + 0xeae20202, 0xebe20202, 0xece20202, 0xede20202, 0xeee20202, 0xefe20202, 0xf0e20202, 0xf1e20202, + 0xf2e20202, 0xf3e20202, 0xf4e20202, 0xf5e20202, 0xf6e20202, 0xf7e20202, 0xf8e20202, 0xf9e20202, + 0xfae20202, 0xfbe20202, 0xfce20202, 0xfde20202, 0xfee20202, 0xffe20202, 0x02e30202, 0x03e30202, + 0x04e30202, 0x05e30202, 0x06e30202, 0x07e30202, 0x08e30202, 0x09e30202, 0x0ae30202, 0x0be30202, + 0x0ce30202, 0x0de30202, 0x0ee30202, 0x0fe30202, 0x10e30202, 0x11e30202, 0x12e30202, 0x13e30202, + 0x14e30202, 0x15e30202, 0x16e30202, 0x17e30202, 0x18e30202, 0x19e30202, 0x1ae30202, 0x1be30202, + 0x1ce30202, 0x1de30202, 0x1ee30202, 0x1fe30202, 0x20e30202, 0x21e30202, 0x22e30202, 0x23e30202, + 0x24e30202, 0x25e30202, 0x26e30202, 0x27e30202, 0x28e30202, 0x29e30202, 0x2ae30202, 0x2be30202, + 0x2ce30202, 0x2de30202, 0x2ee30202, 0x2fe30202, 0x30e30202, 0x31e30202, 0x32e30202, 0x33e30202, + 0x34e30202, 0x35e30202, 0x36e30202, 0x37e30202, 0x38e30202, 0x39e30202, 0x3ae30202, 0x3be30202, + 0x3ce30202, 0x3de30202, 0x3ee30202, 0x3fe30202, 0x40e30202, 0x41e30202, 0x42e30202, 0x43e30202, + 0x44e30202, 0x45e30202, 0x46e30202, 0x47e30202, 0x4de30202, 0x4ee30202, 0x4fe30202, 0x50e30202, + 0x51e30202, 0x52e30202, 0x53e30202, 0x54e30202, 0x55e30202, 0x56e30202, 0x57e30202, 0x58e30202, + 0x59e30202, 0x5ae30202, 0x5be30202, 0x5ce30202, 0x5de30202, 0x5ee30202, 0x5fe30202, 0x60e30202, + 0x61e30202, 0x62e30202, 0x63e30202, 0x64e30202, 0x65e30202, 0x66e30202, 0x67e30202, 0x68e30202, + 0x69e30202, 0x6ae30202, 0x6be30202, 0x6ce30202, 0x6de30202, 0x6ee30202, 0x6fe30202, 0x70e30202, + 0x71e30202, 0x72e30202, 0x73e30202, 0x74e30202, 0x75e30202, 0x76e30202, 0x77e30202, 0x78e30202, + 0x79e30202, 0x7ae30202, 0x7be30202, 0x7ce30202, 0x7de30202, 0x7ee30202, 0x7fe30202, 0x80e30202, + 0x81e30202, 0x82e30202, 0x83e30202, 0x84e30202, 0x85e30202, 0x86e30202, 0x87e30202, 0x88e30202, + 0x89e30202, 0x8ae30202, 0x8be30202, 0x8ce30202, 0x8de30202, 0x8ee30202, 0x8fe30202, 0x90e30202, + 0x91e30202, 0x92e30202, 0x93e30202, 0x94e30202, 0x95e30202, 0x96e30202, 0x97e30202, 0x98e30202, + 0x99e30202, 0x9ae30202, 0x9be30202, 0x9ce30202, 0x9de30202, 0x9ee30202, 0x9fe30202, 0xa0e30202, + 0xa1e30202, 0xa2e30202, 0xa3e30202, 0xa4e30202, 0xa5e30202, 0xa6e30202, 0xa7e30202, 0xa8e30202, + 0xa9e30202, 0xaae30202, 0xabe30202, 0xace30202, 0xade30202, 0xaee30202, 0xafe30202, 0xb0e30202, + 0xb1e30202, 0xb2e30202, 0xb3e30202, 0xb4e30202, 0xb5e30202, 0xb6e30202, 0xb7e30202, 0xb8e30202, + 0xb9e30202, 0xbae30202, 0xbbe30202, 0xbce30202, 0xbde30202, 0xbee30202, 0xbfe30202, 0xc0e30202, + 0xc1e30202, 0xc2e30202, 0xc3e30202, 0xc4e30202, 0xc5e30202, 0xc6e30202, 0xc7e30202, 0xc8e30202, + 0xc9e30202, 0xcae30202, 0xcbe30202, 0xcce30202, 0xcde30202, 0xcee30202, 0xcfe30202, 0xd0e30202, + 0xd1e30202, 0xd2e30202, 0xd3e30202, 0xd4e30202, 0xd5e30202, 0xd6e30202, 0xd7e30202, 0xd8e30202, + 0xd9e30202, 0xdae30202, 0xdbe30202, 0xdce30202, 0xdde30202, 0xdee30202, 0xdfe30202, 0xe0e30202, + 0xe1e30202, 0xe2e30202, 0xe3e30202, 0xe4e30202, 0xe5e30202, 0xe6e30202, 0xe7e30202, 0xe8e30202, + 0xe9e30202, 0xeae30202, 0xebe30202, 0xece30202, 0xede30202, 0xeee30202, 0xefe30202, 0xf0e30202, + 0xf1e30202, 0xf2e30202, 0xf3e30202, 0xf4e30202, 0xf5e30202, 0xf6e30202, 0xf7e30202, 0xf8e30202, + 0xf9e30202, 0xfae30202, 0xfbe30202, 0xfce30202, 0xfde30202, 0xfee30202, 0xffe30202, 0x02e40202, + 0x03e40202, 0x04e40202, 0x05e40202, 0x06e40202, 0x07e40202, 0x08e40202, 0x09e40202, 0x0ae40202, + 0x0be40202, 0x0ce40202, 0x0de40202, 0x0ee40202, 0x0fe40202, 0x10e40202, 0x11e40202, 0x12e40202, + 0x13e40202, 0x14e40202, 0x15e40202, 0x16e40202, 0x17e40202, 0x18e40202, 0x19e40202, 0x1ae40202, + 0x1be40202, 0x1ce40202, 0x1de40202, 0x1ee40202, 0x1fe40202, 0x20e40202, 0x21e40202, 0x22e40202, + 0x23e40202, 0x24e40202, 0x25e40202, 0x26e40202, 0x27e40202, 0x28e40202, 0x29e40202, 0x2ae40202, + 0x2be40202, 0x2ce40202, 0x2de40202, 0x2ee40202, 0x2fe40202, 0x30e40202, 0x31e40202, 0x32e40202, + 0x33e40202, 0x34e40202, 0x35e40202, 0x36e40202, 0x37e40202, 0x38e40202, 0x39e40202, 0x3ae40202, + 0x3be40202, 0x3ce40202, 0x3de40202, 0x3ee40202, 0x3fe40202, 0x40e40202, 0x41e40202, 0x42e40202, + 0x43e40202, 0x44e40202, 0x45e40202, 0x46e40202, 0x47e40202, 0x48e40202, 0x49e40202, 0x4ae40202, + 0x4be40202, 0x4ce40202, 0x4de40202, 0x4ee40202, 0x4fe40202, 0x50e40202, 0x51e40202, 0x52e40202, + 0x53e40202, 0x54e40202, 0x55e40202, 0x56e40202, 0x57e40202, 0x58e40202, 0x59e40202, 0x5ae40202, + 0x5be40202, 0x5ce40202, 0x5de40202, 0x5ee40202, 0x5fe40202, 0x60e40202, 0x61e40202, 0x62e40202, + 0x63e40202, 0x64e40202, 0x65e40202, 0x66e40202, 0x67e40202, 0x68e40202, 0x69e40202, 0x6ae40202, + 0x6be40202, 0x6ce40202, 0x6de40202, 0x6ee40202, 0x6fe40202, 0x70e40202, 0x71e40202, 0x72e40202, + 0x73e40202, 0x74e40202, 0x75e40202, 0x76e40202, 0x77e40202, 0x78e40202, 0x79e40202, 0x7ae40202, + 0x7be40202, 0x7ce40202, 0x7de40202, 0x7ee40202, 0x7fe40202, 0x80e40202, 0x81e40202, 0x82e40202, + 0x83e40202, 0x84e40202, 0x85e40202, 0x86e40202, 0x87e40202, 0x88e40202, 0x89e40202, 0x8ae40202, + 0x8be40202, 0x8ce40202, 0x8de40202, 0x8ee40202, 0x8fe40202, 0x90e40202, 0x91e40202, 0x92e40202, + 0x93e40202, 0x94e40202, 0x95e40202, 0x96e40202, 0x97e40202, 0x98e40202, 0x99e40202, 0x9ae40202, + 0x9be40202, 0x9ce40202, 0x9de40202, 0x9ee40202, 0x9fe40202, 0xa0e40202, 0xa1e40202, 0xa2e40202, + 0xa3e40202, 0xa4e40202, 0xa5e40202, 0xa6e40202, 0xa7e40202, 0xa8e40202, 0xa9e40202, 0xaae40202, + 0xabe40202, 0xace40202, 0xade40202, 0xaee40202, 0xafe40202, 0xb0e40202, 0xb1e40202, 0xb2e40202, + 0xb3e40202, 0xb4e40202, 0xb5e40202, 0xb6e40202, 0xb7e40202, 0xb8e40202, 0xb9e40202, 0xbae40202, + 0xbbe40202, 0xbce40202, 0xbde40202, 0xbee40202, 0xbfe40202, 0xc0e40202, 0xc1e40202, 0xc2e40202, + 0xc3e40202, 0xc4e40202, 0xc5e40202, 0xc6e40202, 0xc7e40202, 0xc8e40202, 0xc9e40202, 0xcae40202, + 0xcbe40202, 0xcce40202, 0xcde40202, 0xcee40202, 0xcfe40202, 0xd0e40202, 0xd1e40202, 0xd2e40202, + 0xd3e40202, 0xd4e40202, 0xd5e40202, 0xd6e40202, 0xd7e40202, 0xd8e40202, 0xd9e40202, 0xdae40202, + 0xdbe40202, 0xdce40202, 0xdde40202, 0xdee40202, 0xdfe40202, 0xe0e40202, 0xe1e40202, 0xe2e40202, + 0xe3e40202, 0xe4e40202, 0xe5e40202, 0xe6e40202, 0xe7e40202, 0xe8e40202, 0xe9e40202, 0xeae40202, + 0xebe40202, 0xece40202, 0xede40202, 0xeee40202, 0xefe40202, 0xf0e40202, 0xf1e40202, 0xf2e40202, + 0xf3e40202, 0xf4e40202, 0xf5e40202, 0xf6e40202, 0xf7e40202, 0xf8e40202, 0xf9e40202, 0xfae40202, + 0xfbe40202, 0xfce40202, 0xfde40202, 0xfee40202, 0xffe40202, 0x02e50202, 0x03e50202, 0x04e50202, + 0x05e50202, 0x06e50202, 0x07e50202, 0x08e50202, 0x09e50202, 0x0ae50202, 0x0be50202, 0x0ce50202, + 0x0de50202, 0x0ee50202, 0x0fe50202, 0x10e50202, 0x11e50202, 0x12e50202, 0x13e50202, 0x14e50202, + 0x15e50202, 0x16e50202, 0x17e50202, 0x18e50202, 0x19e50202, 0x1ae50202, 0x1be50202, 0x1ce50202, + 0x1de50202, 0x1ee50202, 0x1fe50202, 0x20e50202, 0x21e50202, 0x22e50202, 0x23e50202, 0x24e50202, + 0x25e50202, 0x26e50202, 0x27e50202, 0x28e50202, 0x29e50202, 0x2ae50202, 0x2be50202, 0x2ce50202, + 0x2de50202, 0x2ee50202, 0x2fe50202, 0x30e50202, 0x31e50202, 0x32e50202, 0x33e50202, 0x34e50202, + 0x35e50202, 0x36e50202, 0x37e50202, 0x38e50202, 0x39e50202, 0x3ae50202, 0x3be50202, 0x3ce50202, + 0x3de50202, 0x3ee50202, 0x3fe50202, 0x40e50202, 0x41e50202, 0x42e50202, 0x43e50202, 0x44e50202, + 0x45e50202, 0x46e50202, 0x47e50202, 0x48e50202, 0x49e50202, 0x4ae50202, 0x4be50202, 0x4ce50202, + 0x4de50202, 0x4ee50202, 0x4fe50202, 0x50e50202, 0x51e50202, 0x52e50202, 0x53e50202, 0x54e50202, + 0x55e50202, 0x56e50202, 0x57e50202, 0x58e50202, 0x59e50202, 0x5ae50202, 0x5be50202, 0x5ce50202, + 0x5de50202, 0x5ee50202, 0x5fe50202, 0x60e50202, 0x61e50202, 0x62e50202, 0x63e50202, 0x64e50202, + 0x65e50202, 0x66e50202, 0x67e50202, 0x68e50202, 0x69e50202, 0x6ae50202, 0x6be50202, 0x6ce50202, + 0x6de50202, 0x6ee50202, 0x6fe50202, 0x70e50202, 0x71e50202, 0x72e50202, 0x73e50202, 0x74e50202, + 0x75e50202, 0x76e50202, 0x77e50202, 0x78e50202, 0x79e50202, 0x7ae50202, 0x7be50202, 0x7ce50202, + 0x7de50202, 0x7ee50202, 0x7fe50202, 0x80e50202, 0x81e50202, 0x82e50202, 0x83e50202, 0x84e50202, + 0x85e50202, 0x86e50202, 0x87e50202, 0x88e50202, 0x89e50202, 0x8ae50202, 0x8be50202, 0x8ce50202, + 0x8de50202, 0x8ee50202, 0x8fe50202, 0x90e50202, 0x91e50202, 0x92e50202, 0x93e50202, 0x94e50202, + 0x95e50202, 0x96e50202, 0x97e50202, 0x98e50202, 0x99e50202, 0x9ae50202, 0x9be50202, 0x9ce50202, + 0x9ee50202, 0x9fe50202, 0xa0e50202, 0xa1e50202, 0xa2e50202, 0xa3e50202, 0xa4e50202, 0xa5e50202, + 0xa6e50202, 0xa7e50202, 0xa8e50202, 0xa9e50202, 0xaae50202, 0xabe50202, 0xace50202, 0xade50202, + 0xaee50202, 0xafe50202, 0xb0e50202, 0xb1e50202, 0xb2e50202, 0xb3e50202, 0xb4e50202, 0xb5e50202, + 0xb6e50202, 0xb7e50202, 0xb8e50202, 0xb9e50202, 0xbae50202, 0xbbe50202, 0xbce50202, 0xbde50202, + 0xbee50202, 0xbfe50202, 0xc0e50202, 0xc1e50202, 0xc2e50202, 0xc3e50202, 0xc4e50202, 0xc5e50202, + 0xc6e50202, 0xc7e50202, 0xc8e50202, 0xc9e50202, 0xcae50202, 0xcbe50202, 0xcce50202, 0xcde50202, + 0xcee50202, 0xcfe50202, 0xd0e50202, 0xd1e50202, 0xd2e50202, 0xd3e50202, 0xd4e50202, 0xd5e50202, + 0xd6e50202, 0xd7e50202, 0xd8e50202, 0xd9e50202, 0xdae50202, 0xdbe50202, 0xdce50202, 0xdde50202, + 0xdee50202, 0xdfe50202, 0xe0e50202, 0xe1e50202, 0xe2e50202, 0xe3e50202, 0xe4e50202, 0xe5e50202, + 0xe6e50202, 0xe7e50202, 0xe8e50202, 0xe9e50202, 0xeae50202, 0xebe50202, 0xece50202, 0xede50202, + 0xeee50202, 0xefe50202, 0xf0e50202, 0xf1e50202, 0xf2e50202, 0xf3e50202, 0xf4e50202, 0xf5e50202, + 0xf6e50202, 0xf7e50202, 0xf8e50202, 0xf9e50202, 0xfae50202, 0xfbe50202, 0xfce50202, 0xfde50202, + 0xfee50202, 0xffe50202, 0x02e60202, 0x03e60202, 0x04e60202, 0x05e60202, 0x06e60202, 0x07e60202, + 0x08e60202, 0x09e60202, 0x0ae60202, 0x0be60202, 0x0ce60202, 0x0de60202, 0x0ee60202, 0x0fe60202, + 0x10e60202, 0x11e60202, 0x12e60202, 0x13e60202, 0x14e60202, 0x15e60202, 0x16e60202, 0x17e60202, + 0x18e60202, 0x19e60202, 0x1ae60202, 0x1be60202, 0x1ce60202, 0x1de60202, 0x1ee60202, 0x1fe60202, + 0x20e60202, 0x21e60202, 0x22e60202, 0x23e60202, 0x24e60202, 0x25e60202, 0x26e60202, 0x27e60202, + 0x28e60202, 0x29e60202, 0x2ae60202, 0x2be60202, 0x2ce60202, 0x2de60202, 0x2ee60202, 0x2fe60202, + 0x30e60202, 0x31e60202, 0x32e60202, 0x33e60202, 0x34e60202, 0x35e60202, 0x36e60202, 0x37e60202, + 0x38e60202, 0x39e60202, 0x3ae60202, 0x3be60202, 0x3ce60202, 0x3de60202, 0x3ee60202, 0x3fe60202, + 0x40e60202, 0x41e60202, 0x42e60202, 0x43e60202, 0x44e60202, 0x45e60202, 0x46e60202, 0x47e60202, + 0x48e60202, 0x49e60202, 0x4ae60202, 0x4be60202, 0x4ce60202, 0x4de60202, 0x4ee60202, 0x4fe60202, + 0x50e60202, 0x51e60202, 0x52e60202, 0x53e60202, 0x54e60202, 0x55e60202, 0x56e60202, 0x57e60202, + 0x58e60202, 0x59e60202, 0x5ae60202, 0x5be60202, 0x5ce60202, 0x5de60202, 0x5ee60202, 0x5fe60202, + 0x60e60202, 0x61e60202, 0x62e60202, 0x63e60202, 0x64e60202, 0x65e60202, 0x66e60202, 0x67e60202, + 0x68e60202, 0x69e60202, 0x6ae60202, 0x6be60202, 0x6ce60202, 0x6de60202, 0x6ee60202, 0x6fe60202, + 0x70e60202, 0x71e60202, 0x72e60202, 0x73e60202, 0x74e60202, 0x75e60202, 0x76e60202, 0x77e60202, + 0x78e60202, 0x79e60202, 0x7ae60202, 0x7be60202, 0x7ce60202, 0x7de60202, 0x7ee60202, 0x7fe60202, + 0x80e60202, 0x81e60202, 0x82e60202, 0x83e60202, 0x84e60202, 0x85e60202, 0x86e60202, 0x87e60202, + 0x88e60202, 0x89e60502, 0x8ae60202, 0x8be60202, 0x8ce60202, 0x8de60202, 0x8ee60202, 0x8fe60202, + 0x90e60202, 0x91e60202, 0x92e60202, 0x93e60202, 0x94e60202, 0x95e60202, 0x96e60202, 0x97e60202, + 0x98e60202, 0x99e60202, 0x9ae60202, 0x9be60202, 0x9ce60202, 0x9de60202, 0x9ee60202, 0x9fe60202, + 0xa0e60202, 0xa1e60202, 0xa2e60202, 0xa3e60202, 0xa4e60202, 0xa5e60202, 0xa6e60202, 0xa7e60202, + 0xa8e60202, 0xa9e60202, 0xaae60202, 0xabe60202, 0xace60202, 0xade60202, 0xaee60202, 0xafe60202, + 0xb0e60202, 0xb1e60202, 0xb2e60202, 0xb3e60202, 0xb4e60202, 0xb5e60202, 0xb6e60202, 0xb7e60202, + 0xb8e60202, 0xb9e60202, 0xbae60202, 0xbbe60202, 0xbce60202, 0xbde60202, 0xbee60202, 0xbfe60202, + 0xc0e60202, 0xc1e60202, 0xc2e60202, 0xc3e60202, 0xc4e60202, 0xc5e60202, 0xc6e60202, 0xc7e60202, + 0xc8e60202, 0xc9e60202, 0xcae60202, 0xcbe60202, 0xcce60202, 0xcde60202, 0xcee60202, 0xcfe60202, + 0xd0e60202, 0xd1e60202, 0xd2e60202, 0xd3e60202, 0xd4e60202, 0xd5e60202, 0xd6e60202, 0xd7e60202, + 0xd8e60202, 0xd9e60202, 0xdae60202, 0xdbe60202, 0xdce60202, 0xdde60202, 0xdee60202, 0xdfe60202, + 0xe0e60202, 0xe1e60202, 0xe2e60202, 0xe3e60202, 0xe4e60202, 0xe5e60202, 0xe6e60202, 0xe7e60202, + 0xe8e60202, 0xe9e60202, 0xeae60202, 0xebe60202, 0xece60202, 0xede60202, 0xeee60202, 0xefe60202, + 0xf0e60202, 0xf1e60202, 0xf2e60202, 0xf3e60202, 0xf4e60202, 0xf5e60202, 0xf6e60202, 0xf7e60202, + 0xf8e60202, 0xf9e60202, 0xfae60202, 0xfbe60202, 0xfce60202, 0xfde60202, 0xfee60202, 0xffe60202, + 0x02e70202, 0x03e70202, 0x04e70202, 0x05e70202, 0x06e70202, 0x07e70202, 0x08e70202, 0x09e70202, + 0x0ae70202, 0x0be70202, 0x0ce70202, 0x0de70202, 0x0ee70202, 0x0fe70202, 0x10e70202, 0x11e70202, + 0x12e70202, 0x13e70202, 0x14e70202, 0x15e70202, 0x16e70202, 0x17e70202, 0x18e70202, 0x19e70202, + 0x1ae70202, 0x1be70202, 0x1ce70202, 0x1de70202, 0x1ee70202, 0x1fe70202, 0x20e70202, 0x21e70202, + 0x22e70202, 0x23e70202, 0x25e70202, 0x26e70202, 0x27e70202, 0x28e70202, 0x29e70202, 0x2ae70202, + 0x2be70202, 0x2ce70202, 0x2de70202, 0x2ee70202, 0x2fe70202, 0x30e70202, 0x31e70202, 0x32e70202, + 0x33e70202, 0x34e70202, 0x35e70202, 0x36e70202, 0x37e70202, 0x38e70202, 0x39e70202, 0x3ae70202, + 0x3be70202, 0x3ce70202, 0x3de70202, 0x3ee70202, 0x3fe70202, 0x40e70202, 0x41e70202, 0x42e70202, + 0x43e70202, 0x44e70202, 0x45e70202, 0x46e70202, 0x47e70202, 0x48e70202, 0x49e70202, 0x4ae70202, + 0x4be70202, 0x4ce70202, 0x4de70202, 0x4ee70202, 0x4fe70202, 0x50e70202, 0x51e70202, 0x52e70202, + 0x53e70202, 0x54e70202, 0x55e70202, 0x56e70202, 0x57e70202, 0x58e70202, 0x59e70202, 0x5ae70202, + 0x5be70202, 0x5ce70202, 0x5de70202, 0x5ee70202, 0x5fe70202, 0x60e70202, 0x61e70202, 0x62e70202, + 0x63e70202, 0x64e70202, 0x65e70202, 0x66e70202, 0x67e70202, 0x68e70202, 0x69e70202, 0x6ae70202, + 0x6be70202, 0x6ce70202, 0x6de70202, 0x6ee70202, 0x6fe70202, 0x70e70202, 0x71e70202, 0x72e70202, + 0x73e70202, 0x74e70202, 0x75e70202, 0x76e70202, 0x77e70202, 0x78e70202, 0x79e70202, 0x7ae70202, + 0x7be70202, 0x7ce70202, 0x7de70202, 0x7ee70202, 0x7fe70202, 0x80e70202, 0x81e70202, 0x82e70202, + 0x83e70202, 0x84e70202, 0x85e70202, 0x86e70202, 0x87e70202, 0x88e70202, 0x89e70202, 0x8ae70202, + 0x8be70202, 0x8ce70202, 0x8de70202, 0x8ee70202, 0x8fe70202, 0x90e70202, 0x91e70202, 0x92e70202, + 0x93e70202, 0x94e70202, 0x95e70202, 0x96e70202, 0x97e70202, 0x98e70202, 0x99e70202, 0x9ae70202, + 0x9be70202, 0x9ce70202, 0x9de70202, 0x9ee70202, 0x9fe70202, 0xa0e70202, 0xa1e70202, 0xa2e70202, + 0xa3e70202, 0xa4e70202, 0xa5e70202, 0xa6e70202, 0xa7e70202, 0xa8e70202, 0xa9e70202, 0xaae70202, + 0xabe70202, 0xace70202, 0xade70202, 0xaee70202, 0xafe70202, 0xb0e70202, 0xb1e70202, 0xb2e70202, + 0xb3e70202, 0xb4e70202, 0xb5e70202, 0xb6e70202, 0xb7e70202, 0xb8e70202, 0xb9e70202, 0xbae70202, + 0xbbe70202, 0xbce70202, 0xbde70202, 0xbee70202, 0xbfe70202, 0xc0e70202, 0xc1e70202, 0xc2e70202, + 0xc3e70202, 0xc4e70202, 0xc5e70202, 0xc6e70202, 0xc7e70202, 0xc8e70202, 0xc9e70202, 0xcae70202, + 0xcbe70202, 0xcce70202, 0xcde70202, 0xcee70202, 0xcfe70202, 0xd0e70202, 0xd1e70202, 0xd2e70202, + 0xd3e70202, 0xd4e70202, 0xd5e70202, 0xd6e70202, 0xd7e70202, 0xd8e70202, 0xd9e70202, 0xdae70202, + 0xdbe70202, 0xdce70202, 0xdde70202, 0xdee70202, 0xdfe70202, 0xe0e70202, 0xe1e70202, 0xe2e70202, + 0xe3e70202, 0xe4e70202, 0xe5e70202, 0xe6e70202, 0xe7e70202, 0xe8e70202, 0xe9e70202, 0xeae70202, + 0xebe70202, 0xece70202, 0xede70202, 0xeee70202, 0xf0e70202, 0xf1e70202, 0xf2e70202, 0xf3e70202, + 0xf4e70202, 0xf5e70202, 0xf6e70202, 0xf7e70202, 0xf8e70202, 0xf9e70202, 0xfae70202, 0xfbe70202, + 0xfce70202, 0xfde70202, 0xfee70202, 0xffe70202, 0x02e80202, 0x03e80202, 0x04e80202, 0x05e80202, + 0x07e80202, 0x08e80202, 0x09e80202, 0x0ae80202, 0x0be80202, 0x0ce80202, 0x0de80202, 0x0ee80202, + 0x0fe80202, 0x10e80202, 0x11e80202, 0x12e80202, 0x13e80202, 0x14e80202, 0x15e80202, 0x16e80202, + 0x17e80202, 0x18e80202, 0x19e80202, 0x1ae80202, 0x1be80202, 0x1ce80202, 0x1de80202, 0x1ee80202, + 0x1fe80202, 0x20e80202, 0x21e80202, 0x22e80202, 0x23e80202, 0x24e80202, 0x25e80202, 0x26e80202, + 0x27e80202, 0x28e80202, 0x29e80202, 0x2ae80202, 0x2be80202, 0x2ce80202, 0x2de80202, 0x2ee80202, + 0x2fe80202, 0x30e80202, 0x31e80202, 0x32e80202, 0x33e80202, 0x34e80202, 0x35e80202, 0x36e80202, + 0x37e80202, 0x38e80202, 0x39e80202, 0x3ae80202, 0x3be80202, 0x3ce80202, 0x3de80202, 0x3ee80202, + 0x3fe80202, 0x40e80202, 0x41e80202, 0x42e80202, 0x43e80202, 0x44e80202, 0x45e80202, 0x46e80202, + 0x47e80202, 0x48e80202, 0x49e80202, 0x4ae80202, 0x4be80202, 0x4ce80202, 0x4de80202, 0x4ee80202, + 0x4fe80202, 0x50e80202, 0x51e80202, 0x52e80202, 0x53e80202, 0x54e80202, 0x55e80202, 0x56e80202, + 0x57e80202, 0x58e80202, 0x59e80202, 0x5ae80202, 0x5be80202, 0x5ce80202, 0x5de80202, 0x5ee80202, + 0x5fe80202, 0x60e80202, 0x61e80202, 0x62e80202, 0x63e80202, 0x64e80202, 0x65e80202, 0x66e80202, + 0x67e80202, 0x68e80202, 0x69e80202, 0x6ae80202, 0x6be80202, 0x6ce80202, 0x6de80202, 0x6ee80202, + 0x6fe80202, 0x70e80202, 0x71e80202, 0x72e80202, 0x73e80202, 0x74e80202, 0x75e80202, 0x76e80202, + 0x77e80202, 0x78e80202, 0x79e80202, 0x7ae80202, 0x7be80202, 0x7ce80202, 0x7de80202, 0x7ee80202, + 0x7fe80202, 0x80e80202, 0x81e80202, 0x82e80202, 0x83e80202, 0x84e80202, 0x85e80202, 0x86e80202, + 0x87e80202, 0x88e80202, 0x89e80202, 0x8ae80202, 0x8be80202, 0x8ce80202, 0x8de80202, 0x8ee80202, + 0x8fe80202, 0x90e80202, 0x91e80202, 0x92e80202, 0x93e80202, 0x94e80202, 0x95e80202, 0x96e80202, + 0x97e80202, 0x98e80202, 0x99e80202, 0x9ae80202, 0x9be80202, 0x9ce80202, 0x9de80202, 0x9ee80202, + 0x9fe80202, 0xa0e80202, 0xa1e80202, 0xa2e80202, 0xa3e80202, 0xa4e80202, 0xa5e80202, 0xa6e80202, + 0xa7e80202, 0xa8e80202, 0xa9e80202, 0xaae80202, 0xabe80202, 0xace80202, 0xade80202, 0xaee80202, + 0xafe80202, 0xb0e80202, 0xb1e80202, 0xb2e80202, 0xb3e80202, 0xb4e80202, 0xb5e80202, 0xb6e80202, + 0xb7e80202, 0xb8e80202, 0xb9e80202, 0xbae80202, 0xbbe80202, 0xbce80202, 0xbde80202, 0xbee80202, + 0xbfe80202, 0xc0e80202, 0xc1e80202, 0xc2e80202, 0xc3e80202, 0xc4e80202, 0xc5e80202, 0xc6e80202, + 0xc7e80202, 0xc8e80202, 0xc9e80202, 0xcae80202, 0xcbe80202, 0xcce80202, 0xcde80202, 0xcee80202, + 0xcfe80202, 0xd0e80202, 0xd1e80202, 0xd2e80202, 0xd3e80202, 0xd5e80202, 0xd6e80202, 0xd7e80202, + 0xd8e80202, 0xd9e80202, 0xdae80202, 0xdbe80202, 0xdce80202, 0xdde80202, 0xdee80202, 0xdfe80202, + 0xe0e80202, 0xe1e80202, 0xe2e80202, 0xe3e80202, 0xe4e80202, 0xe5e80202, 0xe6e80202, 0xe7e80202, + 0xe8e80202, 0xe9e80202, 0xeae80202, 0xebe80202, 0xece80202, 0xede80202, 0xeee80202, 0xefe80202, + 0xf0e80202, 0xf1e80202, 0xf2e80202, 0xf3e80202, 0xf4e80202, 0xf5e80202, 0xf6e80202, 0xf7e80202, + 0xf8e80202, 0xf9e80202, 0xfae80202, 0xfbe80202, 0xfce80202, 0xfde80202, 0xfee80202, 0xffe80202, + 0x02e90202, 0x03e90202, 0x04e90202, 0x05e90202, 0x06e90202, 0x07e90202, 0x08e90202, 0x09e90202, + 0x0ae90202, 0x0be90202, 0x0ce90202, 0x0de90202, 0x0ee90202, 0x0fe90202, 0x10e90202, 0x11e90202, + 0x12e90202, 0x13e90202, 0x14e90202, 0x15e90202, 0x16e90202, 0x17e90202, 0x18e90202, 0x19e90202, + 0x1ae90202, 0x1be90202, 0x1ce90202, 0x1de90202, 0x1ee90202, 0x1fe90202, 0x20e90202, 0x21e90202, + 0x22e90202, 0x23e90202, 0x24e90202, 0x25e90202, 0x26e90202, 0x27e90202, 0x28e90202, 0x29e90202, + 0x2ae90202, 0x2be90202, 0x2ce90202, 0x2de90202, 0x2ee90202, 0x2fe90202, 0x30e90202, 0x31e90202, + 0x32e90202, 0x33e90202, 0x34e90202, 0x35e90202, 0x36e90202, 0x37e90202, 0x38e90202, 0x39e90202, + 0x3ae90202, 0x3be90202, 0x3ce90202, 0x3de90202, 0x3ee90202, 0x3fe90202, 0x40e90202, 0x41e90202, + 0x42e90202, 0x43e90202, 0x44e90202, 0x45e90202, 0x46e90202, 0x47e90202, 0x48e90202, 0x49e90202, + 0x4ae90202, 0x4be90202, 0x4ce90202, 0x4de90202, 0x4ee90202, 0x4fe90202, 0x50e90202, 0x51e90202, + 0x52e90202, 0x53e90202, 0x54e90202, 0x55e90202, 0x56e90202, 0x57e90202, 0x58e90202, 0x59e90202, + 0x5ae90202, 0x5be90202, 0x5ce90202, 0x5de90202, 0x5ee90202, 0x5fe90202, 0x60e90202, 0x61e90202, + 0x62e90202, 0x63e90202, 0x64e90202, 0x65e90202, 0x66e90202, 0x67e90202, 0x68e90202, 0x69e90202, + 0x6ae90202, 0x6be90202, 0x6ce90202, 0x6de90202, 0x6ee90202, 0x6fe90202, 0x70e90202, 0x71e90202, + 0x72e90202, 0x73e90202, 0x74e90202, 0x75e90202, 0x76e90202, 0x77e90202, 0x78e90202, 0x79e90202, + 0x7ae90202, 0x7be90202, 0x7ce90202, 0x7de90202, 0x7ee90202, 0x7fe90202, 0x80e90202, 0x81e90202, + 0x82e90202, 0x83e90202, 0x84e90202, 0x85e90202, 0x86e90202, 0x87e90202, 0x88e90202, 0x89e90202, + 0x8ae90202, 0x8be90202, 0x8ce90202, 0x8de90202, 0x8ee90202, 0x8fe90202, 0x90e90202, 0x91e90202, + 0x92e90202, 0x93e90202, 0x94e90202, 0x95e90202, 0x96e90202, 0x97e90202, 0x98e90202, 0x99e90202, + 0x9ae90202, 0x9be90202, 0x9ce90202, 0x9de90202, 0x9ee90202, 0x9fe90202, 0xa0e90202, 0xa1e90202, + 0xa2e90202, 0xa3e90202, 0xa4e90202, 0xa5e90202, 0xa6e90202, 0xa7e90202, 0xa8e90202, 0xa9e90202, + 0xaae90202, 0xabe90202, 0xace90202, 0xade90202, 0xaee90202, 0xafe90202, 0xb0e90202, 0xb1e90202, + 0xb2e90202, 0xb3e90202, 0xb4e90202, 0xb5e90202, 0xb6e90202, 0xb7e90202, 0xb8e90202, 0xb9e90202, + 0xbae90202, 0xbbe90202, 0xbce90202, 0xbde90202, 0xbee90202, 0xbfe90202, 0xc0e90202, 0xc1e90202, + 0xc2e90202, 0xc3e90202, 0xc4e90202, 0xc5e90202, 0xc6e90202, 0xc7e90202, 0xc8e90202, 0xc9e90202, + 0xcae90202, 0xcbe90202, 0xcce90202, 0xcde90202, 0xcee90202, 0xcfe90202, 0xd0e90202, 0xd1e90202, + 0xd2e90202, 0xd3e90202, 0xd4e90202, 0xd5e90202, 0xd6e90202, 0xd7e90202, 0xd8e90202, 0xd9e90202, + 0xdae90202, 0xdbe90202, 0xdce90202, 0xdde90202, 0xdee90202, 0xdfe90202, 0xe0e90202, 0xe1e90202, + 0xe2e90202, 0xe3e90202, 0xe4e90202, 0xe5e90202, 0xe6e90202, 0xe7e90202, 0xe8e90202, 0xe9e90202, + 0xeae90202, 0xebe90202, 0xece90202, 0xede90202, 0xeee90202, 0xefe90202, 0xf0e90202, 0xf1e90202, + 0xf2e90202, 0xf3e90202, 0xf4e90202, 0xf5e90202, 0xf6e90202, 0xf7e90202, 0xf8e90202, 0xf9e90202, + 0xfae90202, 0xfbe90202, 0xfce90202, 0xfde90202, 0xfee90202, 0xffe90202, 0x02ea0202, 0x03ea0202, + 0x04ea0202, 0x05ea0202, 0x06ea0202, 0x07ea0202, 0x08ea0202, 0x09ea0202, 0x0aea0202, 0x0bea0202, + 0x0cea0202, 0x0dea0202, 0x0eea0202, 0x0fea0202, 0x10ea0202, 0x11ea0202, 0x12ea0202, 0x13ea0202, + 0x14ea0202, 0x15ea0202, 0x16ea0202, 0x17ea0202, 0x18ea0202, 0x19ea0202, 0x1aea0202, 0x1bea0202, + 0x1cea0202, 0x1dea0202, 0x1eea0202, 0x1fea0202, 0x20ea0202, 0x21ea0202, 0x22ea0202, 0x23ea0202, + 0x24ea0202, 0x25ea0202, 0x26ea0202, 0x27ea0202, 0x28ea0202, 0x29ea0202, 0x2aea0202, 0x2bea0202, + 0x2cea0202, 0x2dea0202, 0x2eea0202, 0x2fea0202, 0x30ea0202, 0x31ea0202, 0x32ea0202, 0x33ea0202, + 0x34ea0202, 0x35ea0202, 0x36ea0202, 0x37ea0202, 0x38ea0202, 0x39ea0202, 0x3aea0202, 0x3bea0202, + 0x3cea0202, 0x3dea0202, 0x3eea0202, 0x3fea0202, 0x40ea0202, 0x41ea0202, 0x42ea0202, 0x43ea0202, + 0x47ea0202, 0x48ea0202, 0x4aea0202, 0x4bea0202, 0x4cea0202, 0x4dea0202, 0x4eea0202, 0x4fea0202, + 0x50ea0202, 0x51ea0202, 0x52ea0202, 0x53ea0202, 0x54ea0202, 0x55ea0202, 0x56ea0202, 0x57ea0202, + 0x58ea0202, 0x59ea0202, 0x5aea0202, 0x5bea0202, 0x5cea0202, 0x5dea0202, 0x5eea0202, 0x5fea0202, + 0x60ea0202, 0x61ea0202, 0x62ea0202, 0x63ea0202, 0x64ea0202, 0x65ea0202, 0x66ea0202, 0x67ea0202, + 0x68ea0202, 0x69ea0202, 0x6aea0202, 0x6bea0202, 0x6cea0202, 0x6dea0202, 0x6eea0202, 0x6fea0202, + 0x70ea0202, 0x71ea0202, 0x72ea0202, 0x73ea0202, 0x74ea0202, 0x75ea0202, 0x76ea0202, 0x77ea0202, + 0x78ea0202, 0x79ea0202, 0x7aea0202, 0x7bea0202, 0x7cea0202, 0x7dea0202, 0x7eea0202, 0x7fea0202, + 0x80ea0202, 0x81ea0202, 0x82ea0202, 0x83ea0202, 0x84ea0202, 0x85ea0202, 0x86ea0202, 0x87ea0202, + 0x88ea0202, 0x89ea0202, 0x8aea0202, 0x8bea0202, 0x8cea0202, 0x8dea0202, 0x8eea0202, 0x8fea0202, + 0x90ea0202, 0x91ea0202, 0x92ea0202, 0x93ea0202, 0x94ea0202, 0x95ea0202, 0x96ea0202, 0x97ea0202, + 0x98ea0202, 0x99ea0202, 0x9aea0202, 0x9bea0202, 0x9cea0202, 0x9dea0202, 0x9eea0202, 0x9fea0202, + 0xa0ea0202, 0xa1ea0202, 0xa2ea0202, 0xa3ea0202, 0xa4ea0202, 0xa5ea0202, 0xa6ea0202, 0xa7ea0202, + 0xa8ea0202, 0xa9ea0202, 0xaaea0202, 0xabea0202, 0xacea0202, 0xadea0202, 0xaeea0202, 0xafea0202, + 0xb0ea0202, 0xb1ea0202, 0xb2ea0202, 0xb3ea0202, 0xb4ea0202, 0xb5ea0202, 0xb6ea0202, 0xb7ea0202, + 0xb8ea0202, 0xb9ea0202, 0xbaea0202, 0xbbea0202, 0xbcea0202, 0xbdea0202, 0xbeea0202, 0xbfea0202, + 0xc0ea0202, 0xc1ea0202, 0xc2ea0202, 0xc3ea0202, 0xc4ea0202, 0xc5ea0202, 0xc6ea0202, 0xc7ea0202, + 0xc8ea0202, 0xc9ea0202, 0xcaea0202, 0xcbea0202, 0xccea0202, 0xcdea0202, 0xceea0202, 0xcfea0202, + 0xd0ea0202, 0xd1ea0202, 0xd2ea0202, 0xd3ea0202, 0xd4ea0202, 0xd5ea0202, 0xd6ea0202, 0xd7ea0202, + 0xd8ea0202, 0xd9ea0202, 0xdaea0202, 0xdbea0202, 0xdcea0202, 0xddea0202, 0xdeea0202, 0xdfea0202, + 0xe0ea0202, 0xe1ea0202, 0xe2ea0202, 0xe3ea0202, 0xe4ea0202, 0xe5ea0202, 0xe6ea0202, 0xe7ea0202, + 0xe8ea0202, 0xe9ea0202, 0xeaea0202, 0xebea0202, 0xecea0202, 0xedea0202, 0xeeea0202, 0xefea0202, + 0xf0ea0202, 0xf1ea0202, 0xf2ea0202, 0xf3ea0202, 0xf4ea0202, 0xf5ea0202, 0xf6ea0202, 0xf7ea0202, + 0xf8ea0202, 0xf9ea0202, 0xfaea0202, 0xfbea0202, 0xfcea0202, 0xfdea0202, 0xfeea0202, 0xffea0202, + 0x02eb0202, 0x03eb0202, 0x04eb0202, 0x05eb0202, 0x06eb0202, 0x07eb0202, 0x08eb0202, 0x09eb0202, + 0x0aeb0202, 0x0beb0202, 0x0ceb0202, 0x0deb0202, 0x0eeb0202, 0x0feb0202, 0x10eb0202, 0x11eb0202, + 0x12eb0202, 0x13eb0202, 0x14eb0202, 0x15eb0202, 0x16eb0202, 0x17eb0202, 0x18eb0202, 0x19eb0202, + 0x1aeb0202, 0x1beb0202, 0x1ceb0202, 0x1deb0202, 0x1eeb0202, 0x1feb0202, 0x20eb0202, 0x21eb0202, + 0x22eb0202, 0x23eb0202, 0x24eb0202, 0x25eb0202, 0x26eb0202, 0x27eb0202, 0x28eb0202, 0x29eb0202, + 0x2aeb0202, 0x2ceb0202, 0x2deb0202, 0x2eeb0202, 0x2feb0202, 0x30eb0202, 0x31eb0202, 0x32eb0202, + 0x33eb0202, 0x34eb0202, 0x35eb0202, 0x36eb0202, 0x37eb0202, 0x38eb0202, 0x39eb0202, 0x3aeb0202, + 0x3beb0202, 0x3ceb0202, 0x3deb0202, 0x3eeb0202, 0x3feb0202, 0x40eb0202, 0x41eb0202, 0x42eb0202, + 0x43eb0202, 0x44eb0202, 0x45eb0202, 0x46eb0202, 0x47eb0202, 0x48eb0202, 0x49eb0202, 0x4aeb0202, + 0x4beb0202, 0x4ceb0202, 0x4deb0202, 0x4eeb0202, 0x4feb0202, 0x50eb0202, 0x51eb0202, 0x52eb0202, + 0x53eb0202, 0x54eb0202, 0x55eb0202, 0x56eb0202, 0x57eb0202, 0x58eb0202, 0x59eb0202, 0x5aeb0202, + 0x5beb0202, 0x5ceb0202, 0x5deb0202, 0x5eeb0202, 0x5feb0202, 0x60eb0202, 0x61eb0202, 0x62eb0202, + 0x63eb0202, 0x64eb0202, 0x65eb0202, 0x66eb0202, 0x67eb0202, 0x68eb0202, 0x69eb0202, 0x6aeb0202, + 0x6beb0202, 0x6ceb0202, 0x6deb0202, 0x6eeb0202, 0x6feb0202, 0x70eb0202, 0x71eb0202, 0x72eb0202, + 0x73eb0202, 0x74eb0202, 0x75eb0202, 0x76eb0202, 0x77eb0202, 0x78eb0202, 0x79eb0202, 0x7aeb0202, + 0x7beb0202, 0x7ceb0202, 0x7deb0202, 0x7eeb0202, 0x7feb0202, 0x80eb0202, 0x81eb0202, 0x82eb0202, + 0x83eb0202, 0x84eb0202, 0x85eb0202, 0x86eb0202, 0x87eb0202, 0x88eb0202, 0x89eb0202, 0x8aeb0202, + 0x8beb0202, 0x8ceb0202, 0x8deb0202, 0x8eeb0202, 0x8feb0202, 0x90eb0202, 0x91eb0202, 0x92eb0202, + 0x93eb0202, 0x94eb0202, 0x95eb0202, 0x96eb0202, 0x97eb0202, 0x98eb0202, 0x99eb0202, 0x9aeb0202, + 0x9beb0202, 0x9ceb0202, 0x9deb0202, 0x9eeb0202, 0x9feb0202, 0xa0eb0202, 0xa1eb0202, 0xa2eb0202, + 0xa3eb0202, 0xa4eb0202, 0xa5eb0202, 0xa6eb0202, 0xa7eb0202, 0xa8eb0202, 0xa9eb0202, 0xaaeb0202, + 0xabeb0202, 0xaceb0202, 0xadeb0202, 0xaeeb0202, 0xafeb0202, 0xb0eb0202, 0xb1eb0202, 0xb2eb0202, + 0xb3eb0202, 0xb4eb0202, 0xb5eb0202, 0xb6eb0202, 0xb7eb0202, 0xb8eb0202, 0xb9eb0202, 0xbaeb0202, + 0xbbeb0202, 0xbceb0202, 0xbdeb0202, 0xbeeb0202, 0xbfeb0202, 0xc0eb0a02, 0xc1eb0202, 0xc2eb0202, + 0xc3eb0202, 0xc4eb0202, 0xc5eb0202, 0xc6eb0202, 0xc7eb0202, 0xc8eb0202, 0xc9eb0202, 0xcaeb0202, + 0xcbeb0202, 0xcceb0202, 0xcdeb0202, 0xceeb0202, 0xcfeb0202, 0xd0eb0202, 0xd1eb0202, 0xd2eb0202, + 0xd3eb0202, 0xd4eb0202, 0xd5eb0202, 0xd6eb0202, 0xd7eb0202, 0xd8eb0202, 0xd9eb0202, 0xdaeb0202, + 0xdbeb0202, 0xdceb0202, 0xddeb0202, 0xdeeb0202, 0xdfeb0202, 0xe0eb0202, 0xe1eb0202, 0xe2eb0202, + 0xe3eb0202, 0xe4eb0202, 0xe5eb0202, 0xe6eb0202, 0xe7eb0202, 0xe8eb0202, 0xe9eb0202, 0xeaeb0202, + 0xebeb0202, 0xeceb0202, 0xedeb0202, 0xeeeb0202, 0xefeb0202, 0xf0eb0202, 0xf1eb0202, 0xf2eb0202, + 0xf3eb0202, 0xf4eb0202, 0xf5eb0202, 0xf6eb0202, 0xf7eb0202, 0xf8eb0202, 0xf9eb0202, 0xfaeb0202, + 0xfbeb0202, 0xfceb0202, 0xfdeb0202, 0xfeeb0202, 0xffeb0202, 0x02ec0202, 0x03ec0202, 0x04ec0202, + 0x05ec0202, 0x06ec0202, 0x07ec0202, 0x08ec0202, 0x09ec0202, 0x0aec0202, 0x0bec0202, 0x0cec0202, + 0x0dec0202, 0x0eec0202, 0x0fec0202, 0x10ec0202, 0x11ec0202, 0x12ec0202, 0x13ec0202, 0x14ec0202, + 0x15ec0202, 0x16ec0202, 0x17ec0202, 0x18ec0202, 0x19ec0202, 0x1aec0202, 0x1bec0202, 0x1cec0202, + 0x1dec0202, 0x1eec0202, 0x1fec0202, 0x20ec0202, 0x21ec0202, 0x22ec0202, 0x23ec0202, 0x24ec0202, + 0x25ec0202, 0x26ec0202, 0x27ec0202, 0x28ec0202, 0x29ec0202, 0x2aec0202, 0x2bec0202, 0x2cec0202, + 0x2dec0202, 0x2eec0202, 0x2fec0202, 0x30ec0202, 0x31ec0202, 0x32ec0202, 0x33ec0202, 0x34ec0202, + 0x35ec0202, 0x36ec0202, 0x37ec0202, 0x38ec0202, 0x39ec0202, 0x3aec0202, 0x3bec0202, 0x3cec0202, + 0x3dec0202, 0x3eec0202, 0x3fec0202, 0x40ec0202, 0x41ec0202, 0x42ec0202, 0x43ec0202, 0x44ec0202, + 0x45ec0202, 0x46ec0202, 0x47ec0202, 0x48ec0202, 0x49ec0202, 0x4aec0202, 0x4bec0202, 0x4cec0202, + 0x4dec0202, 0x4eec0202, 0x4fec0202, 0x50ec0202, 0x51ec0202, 0x52ec0202, 0x53ec0202, 0x54ec0202, + 0x55ec0202, 0x56ec0202, 0x57ec0202, 0x58ec0202, 0x59ec0202, 0x5aec0202, 0x5bec0202, 0x5cec0202, + 0x5dec0202, 0x5eec0202, 0x5fec0202, 0x60ec0202, 0x61ec0202, 0x62ec0202, 0x63ec0202, 0x64ec0202, + 0x65ec0202, 0x66ec0202, 0x67ec0202, 0x68ec0202, 0x69ec0202, 0x6aec0202, 0x6bec0202, 0x6cec0202, + 0x6dec0202, 0x6eec0202, 0x6fec0202, 0x70ec0202, 0x71ec0202, 0x72ec0202, 0x73ec0202, 0x74ec0202, + 0x75ec0202, 0x76ec0202, 0x77ec0202, 0x78ec0202, 0x79ec0202, 0x7aec0202, 0x7bec0202, 0x7cec0202, + 0x7dec0202, 0x7eec0202, 0x7fec0202, 0x80ec0202, 0x81ec0202, 0x82ec0202, 0x83ec0202, 0x84ec0202, + 0x85ec0202, 0x86ec0202, 0x87ec0202, 0x88ec0202, 0x89ec0202, 0x8aec0202, 0x8bec0202, 0x8cec0202, + 0x8dec0202, 0x8eec0202, 0x8fec0202, 0x90ec0202, 0x91ec0202, 0x92ec0202, 0x93ec0202, 0x94ec0202, + 0x95ec0202, 0x96ec0202, 0x97ec0202, 0x98ec0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xed04bc02, 0xed04bf02, 0xed04c302, 0xed04c402, 0xed04c702, 0xed04d102, 0xed04d502, 0xed04d802, + 0xed04dd02, 0xed04e102, 0xed04e202, 0xed04e302, 0xed04e402, 0xed04ec02, 0xed04ed02, 0xed04ee02, + 0xed04ef02, 0xed04f102, 0xed04f202, 0xed04f402, 0xed04f602, 0xed04f902, 0xed04fb02, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0xac041a04, 0xac043804, 0xae040e04, 0xae041404, 0xae042604, + 0xae042c04, 0xae043204, 0xae043804, 0xae043e04, 0xae044404, 0xb0040e04, 0xb0041a04, 0xb0043e04, + 0xb0045604, 0xb0046204, 0xb0047404, 0xb0049804, 0xb004c204, 0xb2040204, 0xb4040e04, 0xb4041404, + 0xb4042604, 0xb4043204, 0xb4044a04, 0xb8041404, 0xb8042004, 0xb8042604, 0xb8042c04, 0xb8043e04, + 0xb8045c04, 0xb8046204, 0xbe042004, 0xbe043204, 0xbe043e04, 0xbe044404, 0xbe045604, 0xbe046204, + 0xbe046804, 0xbe047404, 0xbe048004, 0xc8040804, 0xc8040e04, 0xca042c04, 0xca047a04, 0xce040804, + 0xce040e04, 0xce041a04, 0xe2040e04, 0xe2041404, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x02b03f3f, 0x03b03f3f, 0x04b03f3f, 0x05b03f3f, 0x06b03f3f, 0x07b03f3f, 0x08b03f3f, 0x09b03f3f, + 0x0ab03f3f, 0x0bb03f3f, 0x0cb03f3f, 0x0db03f3f, 0x0eb03f3f, 0x0fb03f3f, 0x10b03f3f, 0x11b03f3f, + 0x12b03f3f, 0x13b03f3f, 0x14b03f3f, 0x15b03f3f, 0x16b03f3f, 0x17b03f3f, 0x18b03f3f, 0x19b03f3f, + 0x1ab03f3f, 0x1bb03f3f, 0x1cb03f3f, 0x1db03f3f, 0x1eb03f3f, 0x1fb03f3f, 0x20b03f3f, 0x21b03f3f, + 0x22b03f3f, 0x23b03f3f, 0x24b03f3f, 0x25b03f3f, 0x26b03f3f, 0x27b03f3f, 0x28b03f3f, 0x29b03f3f, + 0x2ab03f3f, 0x2bb03f3f, 0x2cb03f3f, 0x2db03f3f, 0x2eb03f3f, 0x2fb03f3f, 0x30b03f3f, 0x31b03f3f, + 0x32b03f3f, 0x33b03f3f, 0x34b03f3f, 0x35b03f3f, 0x36b03f3f, 0x37b03f3f, 0x38b03f3f, 0x39b03f3f, + 0x3ab03f3f, 0x3bb03f3f, 0x3cb03f3f, 0x3db03f3f, 0x3eb03f3f, 0x3fb03f3f, 0x40b03f3f, 0x41b03f3f, + 0x02fe3e3e, 0x03fe3e3e, 0x04fe3e3e, 0x05fe3e3e, 0x06fe3e3e, 0x07fe3e3e, 0x08fe3e3e, 0x09fe3e3e, + 0x0afe3e3e, 0x0bfe3e3e, 0x0cfe3e3e, 0x0dfe3e3e, 0x0efe3e3e, 0x0ffe3e3e, 0x10fe3e3e, 0x11fe3e3e, + 0x12fe3e3e, 0x13fe3e3e, 0x14fe3e3e, 0x15fe3e3e, 0x16fe3e3e, 0x17fe3e3e, 0x18fe3e3e, 0x19fe3e3e, + 0x1afe3e3e, 0x1bfe3e3e, 0x1cfe3e3e, 0x1dfe3e3e, 0x1efe3e3e, 0x1ffe3e3e, 0x20fe3e3e, 0x21fe3e3e, + 0x22fe3e3e, 0x23fe3e3e, 0x24fe3e3e, 0x25fe3e3e, 0x26fe3e3e, 0x27fe3e3e, 0x28fe3e3e, 0x29fe3e3e, + 0x2afe3e3e, 0x2bfe3e3e, 0x2cfe3e3e, 0x2dfe3e3e, 0x2efe3e3e, 0x2ffe3e3e, 0x30fe3e3e, 0x31fe3e3e, + 0x32fe3e3e, 0x33fe3e3e, 0x34fe3e3e, 0x35fe3e3e, 0x36fe3e3e, 0x37fe3e3e, 0x38fe3e3e, 0x39fe3e3e, + 0x3afe3e3e, 0x3bfe3e3e, 0x3cfe3e3e, 0x3dfe3e3e, 0x3efe3e3e, 0x3ffe3e3e, 0x40fe3e3e, 0x41fe3e3e, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x02ff3e3e, 0x03ff3e3e, 0x04ff3e3e, 0x05ff3e3e, 0x06ff3e3e, 0x07ff3e3e, 0x08ff3e3e, 0x09ff3e3e, + 0x0aff3e3e, 0x0bff3e3e, 0x0cff3e3e, 0x0dff3e3e, 0x0eff3e3e, 0x0fff3e3e, 0x10ff3e3e, 0x11ff3e3e, + 0x12ff3e3e, 0x13ff3e3e, 0x14ff3e3e, 0x15ff3e3e, 0x16ff3e3e, 0x17ff3e3e, 0x18ff3e3e, 0x19ff3e3e, + 0x1aff3e3e, 0x1bff3e3e, 0x1cff3e3e, 0x1dff3e3e, 0x1eff3e3e, 0x1fff3e3e, 0x20ff3e3e, 0x21ff3e3e, + 0x22ff3e3e, 0x23ff3e3e, 0x24ff3e3e, 0x25ff3e3e, 0x26ff3e3e, 0x27ff3e3e, 0x28ff3e3e, 0x29ff3e3e, + 0x2aff3e3e, 0x2bff3e3e, 0x2cff3e3e, 0x2dff3e3e, 0x2eff3e3e, 0x2fff3e3e, 0x30ff3e3e, 0x31ff3e3e, + 0x32ff3e3e, 0x33ff3e3e, 0x34ff3e3e, 0x35ff3e3e, 0x36ff3e3e, 0x37ff3e3e, 0x38ff3e3e, 0x39ff3e3e, + 0x3aff3e3e, 0x3bff3e3e, 0x3cff3e3e, 0x3dff3e3e, 0x3eff3e3e, 0x3fff3e3e, 0x40ff3e3e, 0x41ff3e3e, + 0x42ff3e3e, 0x43ff3e3e, 0x44ff3e3e, 0x45ff3e3e, 0x46ff3e3e, 0x47ff3e3e, 0x48ff3e3e, 0x49ff3e3e, + 0x4aff3e3e, 0x4bff3e3e, 0x4cff3e3e, 0x4dff3e3e, 0x4eff3e3e, 0x4fff3e3e, 0x50ff3e3e, 0x51ff3e3e, + 0x52ff3e3e, 0x53ff3e3e, 0x54ff3e3e, 0x55ff3e3e, 0x56ff3e3e, 0x57ff3e3e, 0x58ff3e3e, 0x59ff3e3e, + 0x5aff3e3e, 0x5bff3e3e, 0x5cff3e3e, 0x5dff3e3e, 0x5eff3e3e, 0x5fff3e3e, 0x60ff3e3e, 0x61ff3e3e, + 0x62ff3e3e, 0x63ff3e3e, 0x64ff3e3e, 0x65ff3e3e, 0x66ff3e3e, 0x67ff3e3e, 0x68ff3e3e, 0x69ff3e3e, + 0x6aff3e3e, 0x6bff3e3e, 0x6cff3e3e, 0x6dff3e3e, 0x6eff3e3e, 0x6fff3e3e, 0x70ff3e3e, 0x71ff3e3e, + 0x72ff3e3e, 0x73ff3e3e, 0x74ff3e3e, 0x75ff3e3e, 0x76ff3e3e, 0x77ff3e3e, 0x78ff3e3e, 0x79ff3e3e, + 0x7aff3e3e, 0x7bff3e3e, 0x7cff3e3e, 0x7dff3e3e, 0x7eff3e3e, 0x7fff3e3e, 0x80ff3e3e, 0x81ff3e3e, + 0xf8b43f3f, 0xf9b43f3f, 0xfab43f3f, 0xfbb43f3f, 0xfcb43f3f, 0xfdb43f3f, 0xfeb43f3f, 0xffb43f3f, + 0x02b53f3f, 0x03b53f3f, 0x04b53f3f, 0x05b53f3f, 0x06b53f3f, 0x07b53f3f, 0x08b53f3f, 0x09b53f3f, + 0x0ab53f3f, 0x0bb53f3f, 0x0cb53f3f, 0x0db53f3f, 0x0eb53f3f, 0x0fb53f3f, 0x10b53f3f, 0x11b53f3f, + 0x12b53f3f, 0x13b53f3f, 0x14b53f3f, 0x15b53f3f, 0x16b53f3f, 0x17b53f3f, 0x18b53f3f, 0x19b53f3f, + 0x1ab53f3f, 0x1bb53f3f, 0x1cb53f3f, 0x1db53f3f, 0x1eb53f3f, 0x1fb53f3f, 0x20b53f3f, 0x21b53f3f, + 0x22b53f3f, 0x23b53f3f, 0x24b53f3f, 0x25b53f3f, 0x26b53f3f, 0x27b53f3f, 0x28b53f3f, 0x29b53f3f, + 0x2ab53f3f, 0x2bb53f3f, 0x2cb53f3f, 0x2db53f3f, 0x2eb53f3f, 0x2fb53f3f, 0x30b53f3f, 0x31b53f3f, + 0x32b53f3f, 0x33b53f3f, 0x34b53f3f, 0x35b53f3f, 0x36b53f3f, 0x37b53f3f, 0x38b53f3f, 0x39b53f3f, + 0x3ab53f3f, 0x3bb53f3f, 0x3cb53f3f, 0x3db53f3f, 0x3eb53f3f, 0x3fb53f3f, 0x40b53f3f, 0x41b53f3f, + 0x42b53f3f, 0x43b53f3f, 0x44b53f3f, 0x45b53f3f, 0x46b53f3f, 0x47b53f3f, 0x48b53f3f, 0x49b53f3f, + 0x4ab53f3f, 0x4bb53f3f, 0x4cb53f3f, 0x4db53f3f, 0x4eb53f3f, 0x4fb53f3f, 0x50b53f3f, 0x51b53f3f, + 0x52b53f3f, 0x53b53f3f, 0x54b53f3f, 0x55b53f3f, 0x56b53f3f, 0x57b53f3f, 0x58b53f3f, 0x59b53f3f, + 0x5ab53f3f, 0x5bb53f3f, 0x5cb53f3f, 0x5db53f3f, 0x5eb53f3f, 0x5fb53f3f, 0x60b53f3f, 0x61b53f3f, + 0x62b53f3f, 0x63b53f3f, 0x64b53f3f, 0x65b53f3f, 0x66b53f3f, 0x67b53f3f, 0x68b53f3f, 0x69b53f3f, + 0x6ab53f3f, 0x6bb53f3f, 0x6cb53f3f, 0x6db53f3f, 0x6eb53f3f, 0x6fb53f3f, 0x70b53f3f, 0x71b53f3f, + 0x72b53f3f, 0x73b53f3f, 0x74b53f3f, 0x75b53f3f, 0x76b53f3f, 0x77b53f3f, 0x78b53f3f, 0x79b53f3f, + 0x7ab53f3f, 0x7bb53f3f, 0x7cb53f3f, 0x7db53f3f, 0x7eb53f3f, 0x7fb53f3f, 0x80b53f3f, 0x81b53f3f, + 0x82b53f3f, 0x83b53f3f, 0x84b53f3f, 0x85b53f3f, 0x86b53f3f, 0x87b53f3f, 0x88b53f3f, 0x89b53f3f, + 0x8ab53f3f, 0x8bb53f3f, 0x8cb53f3f, 0x8db53f3f, 0x8eb53f3f, 0x8fb53f3f, 0x90b53f3f, 0x91b53f3f, + 0x92b53f3f, 0x93b53f3f, 0x94b53f3f, 0x95b53f3f, 0x96b53f3f, 0x97b53f3f, 0x98b53f3f, 0x99b53f3f, + 0x9ab53f3f, 0x9bb53f3f, 0x9cb53f3f, 0x9db53f3f, 0x9eb53f3f, 0x9fb53f3f, 0xa0b53f3f, 0xa1b53f3f, + 0xa2b53f3f, 0xa3b53f3f, 0xa4b53f3f, 0xa5b53f3f, 0xa6b53f3f, 0xa7b53f3f, 0xa8b53f3f, 0xa9b53f3f, + 0xaab53f3f, 0xabb53f3f, 0xacb53f3f, 0xadb53f3f, 0xaeb53f3f, 0xafb53f3f, 0xb0b53f3f, 0xb1b53f3f, + 0xb2b53f3f, 0xb3b53f3f, 0xb4b53f3f, 0xb5b53f3f, 0xb6b53f3f, 0xb7b53f3f, 0xb8b53f3f, 0xb9b53f3f, + 0xbab53f3f, 0xbbb53f3f, 0xbcb53f3f, 0xbdb53f3f, 0xbeb53f3f, 0xbfb53f3f, 0xc0b53f3f, 0xc1b53f3f, + 0xc2b53f3f, 0xc3b53f3f, 0xc4b53f3f, 0xc5b53f3f, 0xc6b53f3f, 0xc7b53f3f, 0xc8b53f3f, 0xc9b53f3f, + 0xcab53f3f, 0xcbb53f3f, 0xccb53f3f, 0xcdb53f3f, 0xceb53f3f, 0xcfb53f3f, 0xd0b53f3f, 0xd1b53f3f, + 0xd2b53f3f, 0xd3b53f3f, 0xd4b53f3f, 0xd5b53f3f, 0xd6b53f3f, 0xd7b53f3f, 0xd8b53f3f, 0xd9b53f3f, + 0xdab53f3f, 0xdbb53f3f, 0xdcb53f3f, 0xddb53f3f, 0xdeb53f3f, 0xdfb53f3f, 0xe0b53f3f, 0xe1b53f3f, + 0xe2b53f3f, 0xe3b53f3f, 0xe4b53f3f, 0xe5b53f3f, 0xe6b53f3f, 0xe7b53f3f, 0xe8b53f3f, 0xe9b53f3f, + 0xeab53f3f, 0xebb53f3f, 0xecb53f3f, 0xedb53f3f, 0xeeb53f3f, 0xefb53f3f, 0xf0b53f3f, 0xf1b53f3f, + 0xf2b53f3f, 0xf3b53f3f, 0xf4b53f3f, 0xf5b53f3f, 0xf6b53f3f, 0xf7b53f3f, 0xf8b53f3f, 0xf9b53f3f, + 0xfab53f3f, 0xfbb53f3f, 0xfcb53f3f, 0xfdb53f3f, 0xfeb53f3f, 0xffb53f3f, 0x02b63f3f, 0x03b63f3f, + 0x04b63f3f, 0x05b63f3f, 0x06b63f3f, 0x07b63f3f, 0x08b63f3f, 0x09b63f3f, 0x0ab63f3f, 0x0bb63f3f, + 0x0cb63f3f, 0x0db63f3f, 0x0eb63f3f, 0x0fb63f3f, 0x10b63f3f, 0x11b63f3f, 0x12b63f3f, 0x13b63f3f, + 0x14b63f3f, 0x15b63f3f, 0x16b63f3f, 0x17b63f3f, 0x18b63f3f, 0x19b63f3f, 0x1ab63f3f, 0x1bb63f3f, + 0x1cb63f3f, 0x1db63f3f, 0x1eb63f3f, 0x1fb63f3f, 0x20b63f3f, 0x21b63f3f, 0x22b63f3f, 0x23b63f3f, + 0x24b63f3f, 0x25b63f3f, 0x26b63f3f, 0x27b63f3f, 0x28b63f3f, 0x29b63f3f, 0x2ab63f3f, 0x2bb63f3f, + 0x2cb63f3f, 0x2db63f3f, 0x2eb63f3f, 0x2fb63f3f, 0x30b63f3f, 0x31b63f3f, 0x32b63f3f, 0x33b63f3f, + 0x34b63f3f, 0x35b63f3f, 0x36b63f3f, 0x37b63f3f, 0x38b63f3f, 0x39b63f3f, 0x3ab63f3f, 0x3bb63f3f, + 0x3cb63f3f, 0x3db63f3f, 0x3eb63f3f, 0x3fb63f3f, 0x40b63f3f, 0x41b63f3f, 0x42b63f3f, 0x43b63f3f, + 0x44b63f3f, 0x45b63f3f, 0x46b63f3f, 0x47b63f3f, 0x48b63f3f, 0x49b63f3f, 0x4ab63f3f, 0x4bb63f3f, + 0x4cb63f3f, 0x4db63f3f, 0x4eb63f3f, 0x4fb63f3f, 0x50b63f3f, 0x51b63f3f, 0x52b63f3f, 0x53b63f3f, + 0x54b63f3f, 0x55b63f3f, 0x56b63f3f, 0x57b63f3f, 0x58b63f3f, 0x59b63f3f, 0x5ab63f3f, 0x5bb63f3f, + 0x5cb63f3f, 0x5db63f3f, 0x5eb63f3f, 0x5fb63f3f, 0x60b63f3f, 0x61b63f3f, 0x62b63f3f, 0x63b63f3f, + 0x64b63f3f, 0x65b63f3f, 0x66b63f3f, 0x67b63f3f, 0x68b63f3f, 0x69b63f3f, 0x6ab63f3f, 0x6bb63f3f, + 0x6cb63f3f, 0x6db63f3f, 0x6eb63f3f, 0x6fb63f3f, 0x70b63f3f, 0x71b63f3f, 0x72b63f3f, 0x73b63f3f, + 0x74b63f3f, 0x75b63f3f, 0x76b63f3f, 0x77b63f3f, 0x78b63f3f, 0x79b63f3f, 0x7ab63f3f, 0x7bb63f3f, + 0x7cb63f3f, 0x7db63f3f, 0x7eb63f3f, 0x7fb63f3f, 0x80b63f3f, 0x81b63f3f, 0x82b63f3f, 0x83b63f3f, + 0x84b63f3f, 0x85b63f3f, 0x86b63f3f, 0x87b63f3f, 0x88b63f3f, 0x89b63f3f, 0x8ab63f3f, 0x8bb63f3f, + 0x8cb63f3f, 0x8db63f3f, 0x8eb63f3f, 0x8fb63f3f, 0x90b63f3f, 0x91b63f3f, 0x92b63f3f, 0x93b63f3f, + 0x94b63f3f, 0x95b63f3f, 0x96b63f3f, 0x97b63f3f, 0x98b63f3f, 0x99b63f3f, 0x9ab63f3f, 0x9bb63f3f, + 0x9cb63f3f, 0x9db63f3f, 0x9eb63f3f, 0x9fb63f3f, 0xa0b63f3f, 0xa1b63f3f, 0xa2b63f3f, 0xa3b63f3f, + 0xa4b63f3f, 0xa5b63f3f, 0xa6b63f3f, 0xa7b63f3f, 0xa8b63f3f, 0xa9b63f3f, 0xaab63f3f, 0xabb63f3f, + 0xacb63f3f, 0xadb63f3f, 0xaeb63f3f, 0xafb63f3f, 0xb0b63f3f, 0xb1b63f3f, 0xb2b63f3f, 0xb3b63f3f, + 0xb4b63f3f, 0xb5b63f3f, 0xb6b63f3f, 0xb7b63f3f, 0xb8b63f3f, 0xb9b63f3f, 0xbab63f3f, 0xbbb63f3f, + 0xbcb63f3f, 0xbdb63f3f, 0xbeb63f3f, 0xbfb63f3f, 0xc0b63f3f, 0xc1b63f3f, 0xc2b63f3f, 0xc3b63f3f, + 0xc4b63f3f, 0xc5b63f3f, 0xc6b63f3f, 0xc7b63f3f, 0xc8b63f3f, 0xc9b63f3f, 0xcab63f3f, 0xcbb63f3f, + 0xccb63f3f, 0xcdb63f3f, 0xceb63f3f, 0xcfb63f3f, 0xd0b63f3f, 0xd1b63f3f, 0xd2b63f3f, 0xd3b63f3f, + 0xd4b63f3f, 0xd5b63f3f, 0xd6b63f3f, 0xd7b63f3f, 0xd8b63f3f, 0xd9b63f3f, 0xdab63f3f, 0xdbb63f3f, + 0xdcb63f3f, 0xddb63f3f, 0xdeb63f3f, 0xdfb63f3f, 0xe0b63f3f, 0xe1b63f3f, 0xe2b63f3f, 0xe3b63f3f, + 0xe4b63f3f, 0xe5b63f3f, 0xe6b63f3f, 0xe7b63f3f, 0xe8b63f3f, 0xe9b63f3f, 0xeab63f3f, 0xebb63f3f, + 0xecb63f3f, 0xedb63f3f, 0xeeb63f3f, 0xefb63f3f, 0xf0b63f3f, 0xf1b63f3f, 0xf2b63f3f, 0xf3b63f3f, + 0xf4b63f3f, 0xf5b63f3f, 0xf6b63f3f, 0xf7b63f3f, 0xf8b63f3f, 0xf9b63f3f, 0xfab63f3f, 0xfbb63f3f, + 0xfcb63f3f, 0xfdb63f3f, 0xfeb63f3f, 0xffb63f3f, 0x02b73f3f, 0x03b73f3f, 0x04b73f3f, 0x05b73f3f, + 0x06b73f3f, 0x07b73f3f, 0x08b73f3f, 0x09b73f3f, 0x0ab73f3f, 0x0bb73f3f, 0x0cb73f3f, 0x0db73f3f, + 0x0eb73f3f, 0x0fb73f3f, 0x10b73f3f, 0x11b73f3f, 0x12b73f3f, 0x13b73f3f, 0x14b73f3f, 0x15b73f3f, + 0x16b73f3f, 0x17b73f3f, 0x18b73f3f, 0x19b73f3f, 0x1ab73f3f, 0x1bb73f3f, 0x1cb73f3f, 0x1db73f3f, + 0x1eb73f3f, 0x1fb73f3f, 0x20b73f3f, 0x21b73f3f, 0x22b73f3f, 0x23b73f3f, 0x24b73f3f, 0x25b73f3f, + 0x26b73f3f, 0x27b73f3f, 0x28b73f3f, 0x29b73f3f, 0x2ab73f3f, 0x2bb73f3f, 0x2cb73f3f, 0x2db73f3f, + 0x2eb73f3f, 0x2fb73f3f, 0x30b73f3f, 0x31b73f3f, 0x32b73f3f, 0x33b73f3f, 0x34b73f3f, 0x35b73f3f, + 0x36b73f3f, 0x37b73f3f, 0x38b73f3f, 0x39b73f3f, 0x3ab73f3f, 0x3bb73f3f, 0x3cb73f3f, 0x3db73f3f, + 0x3eb73f3f, 0x3fb73f3f, 0x40b73f3f, 0x41b73f3f, 0x42b73f3f, 0x43b73f3f, 0x44b73f3f, 0x45b73f3f, + 0x46b73f3f, 0x47b73f3f, 0x48b73f3f, 0x49b73f3f, 0x4ab73f3f, 0x4bb73f3f, 0x4cb73f3f, 0x4db73f3f, + 0x4eb73f3f, 0x4fb73f3f, 0x50b73f3f, 0x51b73f3f, 0x52b73f3f, 0x53b73f3f, 0x54b73f3f, 0x55b73f3f, + 0x56b73f3f, 0x57b73f3f, 0x58b73f3f, 0x59b73f3f, 0x5ab73f3f, 0x5bb73f3f, 0x5cb73f3f, 0x5db73f3f, + 0x5eb73f3f, 0x5fb73f3f, 0x60b73f3f, 0x61b73f3f, 0x62b73f3f, 0x63b73f3f, 0x64b73f3f, 0x65b73f3f, + 0x66b73f3f, 0x67b73f3f, 0x68b73f3f, 0x69b73f3f, 0x6ab73f3f, 0x6bb73f3f, 0x6cb73f3f, 0x6db73f3f, + 0x6eb73f3f, 0x6fb73f3f, 0x70b73f3f, 0x71b73f3f, 0x72b73f3f, 0x73b73f3f, 0x74b73f3f, 0x75b73f3f, + 0x76b73f3f, 0x77b73f3f, 0x78b73f3f, 0x79b73f3f, 0x7ab73f3f, 0x7bb73f3f, 0x7cb73f3f, 0x7db73f3f, + 0x7eb73f3f, 0x7fb73f3f, 0x80b73f3f, 0x81b73f3f, 0x82b73f3f, 0x83b73f3f, 0x84b73f3f, 0x85b73f3f, + 0x86b73f3f, 0x87b73f3f, 0x88b73f3f, 0x89b73f3f, 0x8ab73f3f, 0x8bb73f3f, 0x8cb73f3f, 0x8db73f3f, + 0x8eb73f3f, 0x8fb73f3f, 0x90b73f3f, 0x91b73f3f, 0x92b73f3f, 0x93b73f3f, 0x94b73f3f, 0x95b73f3f, + 0x96b73f3f, 0x97b73f3f, 0x98b73f3f, 0x99b73f3f, 0x9ab73f3f, 0x9bb73f3f, 0x9cb73f3f, 0x9db73f3f, + 0x9eb73f3f, 0x9fb73f3f, 0xa0b73f3f, 0xa1b73f3f, 0xa2b73f3f, 0xa3b73f3f, 0xa4b73f3f, 0xa5b73f3f, + 0xa6b73f3f, 0xa7b73f3f, 0xa8b73f3f, 0xa9b73f3f, 0xaab73f3f, 0xabb73f3f, 0xacb73f3f, 0xadb73f3f, + 0xaeb73f3f, 0xafb73f3f, 0xb0b73f3f, 0xb1b73f3f, 0xb2b73f3f, 0xb3b73f3f, 0xb4b73f3f, 0xb5b73f3f, + 0xb6b73f3f, 0xb7b73f3f, 0xb8b73f3f, 0xb9b73f3f, 0xbab73f3f, 0xbbb73f3f, 0xbcb73f3f, 0xbdb73f3f, + 0xbeb73f3f, 0xbfb73f3f, 0xc0b73f3f, 0xc1b73f3f, 0xc2b73f3f, 0xc3b73f3f, 0xc4b73f3f, 0xc5b73f3f, + 0xc6b73f3f, 0xc7b73f3f, 0xc8b73f3f, 0xc9b73f3f, 0xcab73f3f, 0xcbb73f3f, 0xccb73f3f, 0xcdb73f3f, + 0xceb73f3f, 0xcfb73f3f, 0xd0b73f3f, 0xd1b73f3f, 0xd2b73f3f, 0xd3b73f3f, 0xd4b73f3f, 0xd5b73f3f, + 0xd6b73f3f, 0xd7b73f3f, 0xd8b73f3f, 0xd9b73f3f, 0xdab73f3f, 0xdbb73f3f, 0xdcb73f3f, 0xddb73f3f, + 0xdeb73f3f, 0xdfb73f3f, 0xe0b73f3f, 0xe1b73f3f, 0xe2b73f3f, 0xe3b73f3f, 0xe4b73f3f, 0xe5b73f3f, + 0xe6b73f3f, 0xe7b73f3f, 0xe8b73f3f, 0xe9b73f3f, 0xeab73f3f, 0xebb73f3f, 0xecb73f3f, 0xedb73f3f, + 0xeeb73f3f, 0xefb73f3f, 0xf0b73f3f, 0xf1b73f3f, 0xf2b73f3f, 0xf3b73f3f, 0xf4b73f3f, 0xf5b73f3f, + 0xf6b73f3f, 0xf7b73f3f, 0xf8b73f3f, 0xf9b73f3f, 0xfab73f3f, 0xfbb73f3f, 0xfcb73f3f, 0xfdb73f3f, + 0xfeb73f3f, 0xffb73f3f, 0x02b83f3f, 0x03b83f3f, 0x04b83f3f, 0x05b83f3f, 0x06b83f3f, 0x07b83f3f, + 0x08b83f3f, 0x09b83f3f, 0x0ab83f3f, 0x0bb83f3f, 0x0cb83f3f, 0x0db83f3f, 0x0eb83f3f, 0x0fb83f3f, + 0x10b83f3f, 0x11b83f3f, 0x12b83f3f, 0x13b83f3f, 0x14b83f3f, 0x15b83f3f, 0x16b83f3f, 0x17b83f3f, + 0x18b83f3f, 0x19b83f3f, 0x1ab83f3f, 0x1bb83f3f, 0x1cb83f3f, 0x1db83f3f, 0x1eb83f3f, 0x1fb83f3f, + 0x20b83f3f, 0x21b83f3f, 0x22b83f3f, 0x23b83f3f, 0x24b83f3f, 0x25b83f3f, 0x26b83f3f, 0x27b83f3f, + 0x28b83f3f, 0x29b83f3f, 0x2ab83f3f, 0x2bb83f3f, 0x2cb83f3f, 0x2db83f3f, 0x2eb83f3f, 0x2fb83f3f, + 0x30b83f3f, 0x31b83f3f, 0x32b83f3f, 0x33b83f3f, 0x34b83f3f, 0x35b83f3f, 0x36b83f3f, 0x37b83f3f, + 0x38b83f3f, 0x39b83f3f, 0x3ab83f3f, 0x3bb83f3f, 0x3cb83f3f, 0x3db83f3f, 0x3eb83f3f, 0x3fb83f3f, + 0x40b83f3f, 0x41b83f3f, 0x42b83f3f, 0x43b83f3f, 0x44b83f3f, 0x45b83f3f, 0x46b83f3f, 0x47b83f3f, + 0x48b83f3f, 0x49b83f3f, 0x4ab83f3f, 0x4bb83f3f, 0x4cb83f3f, 0x4db83f3f, 0x4eb83f3f, 0x4fb83f3f, + 0x50b83f3f, 0x51b83f3f, 0x52b83f3f, 0x53b83f3f, 0x54b83f3f, 0x55b83f3f, 0x56b83f3f, 0x57b83f3f, + 0x58b83f3f, 0x59b83f3f, 0x5ab83f3f, 0x5bb83f3f, 0x5cb83f3f, 0x5db83f3f, 0x5eb83f3f, 0x5fb83f3f, + 0x60b83f3f, 0x61b83f3f, 0x62b83f3f, 0x63b83f3f, 0x64b83f3f, 0x65b83f3f, 0x66b83f3f, 0x67b83f3f, + 0x68b83f3f, 0x69b83f3f, 0x6ab83f3f, 0x6bb83f3f, 0x6cb83f3f, 0x6db83f3f, 0x6eb83f3f, 0x6fb83f3f, + 0x70b83f3f, 0x71b83f3f, 0x72b83f3f, 0x73b83f3f, 0x74b83f3f, 0x75b83f3f, 0x76b83f3f, 0x77b83f3f, + 0x78b83f3f, 0x79b83f3f, 0x7ab83f3f, 0x7bb83f3f, 0x7cb83f3f, 0x7db83f3f, 0x7eb83f3f, 0x7fb83f3f, + 0x80b83f3f, 0x81b83f3f, 0x82b83f3f, 0x83b83f3f, 0x84b83f3f, 0x85b83f3f, 0x86b83f3f, 0x87b83f3f, + 0x88b83f3f, 0x89b83f3f, 0x8ab83f3f, 0x8bb83f3f, 0x8cb83f3f, 0x8db83f3f, 0x8eb83f3f, 0x8fb83f3f, + 0x90b83f3f, 0x91b83f3f, 0x92b83f3f, 0x93b83f3f, 0x94b83f3f, 0x95b83f3f, 0x96b83f3f, 0x97b83f3f, + 0x98b83f3f, 0x99b83f3f, 0x9ab83f3f, 0x9bb83f3f, 0x9cb83f3f, 0x9db83f3f, 0x9eb83f3f, 0x9fb83f3f, + 0xa0b83f3f, 0xa1b83f3f, 0xa2b83f3f, 0xa3b83f3f, 0xa4b83f3f, 0xa5b83f3f, 0xa6b83f3f, 0xa7b83f3f, + 0xa8b83f3f, 0xa9b83f3f, 0xaab83f3f, 0xabb83f3f, 0xacb83f3f, 0xadb83f3f, 0xaeb83f3f, 0xafb83f3f, + 0xb0b83f3f, 0xb1b83f3f, 0xb2b83f3f, 0xb3b83f3f, 0xb4b83f3f, 0xb5b83f3f, 0xb6b83f3f, 0xb7b83f3f, + 0xb8b83f3f, 0xb9b83f3f, 0xbab83f3f, 0xbbb83f3f, 0xbcb83f3f, 0xbdb83f3f, 0xbeb83f3f, 0xbfb83f3f, + 0xc0b83f3f, 0xc1b83f3f, 0xc2b83f3f, 0xc3b83f3f, 0xc4b83f3f, 0xc5b83f3f, 0xc6b83f3f, 0xc7b83f3f, + 0xc8b83f3f, 0xc9b83f3f, 0xcab83f3f, 0xcbb83f3f, 0xccb83f3f, 0xcdb83f3f, 0xceb83f3f, 0xcfb83f3f, + 0xd0b83f3f, 0xd1b83f3f, 0xd2b83f3f, 0xd3b83f3f, 0xd4b83f3f, 0xd5b83f3f, 0xd6b83f3f, 0xd7b83f3f, + 0xd8b83f3f, 0xd9b83f3f, 0xdab83f3f, 0xdbb83f3f, 0xdcb83f3f, 0xddb83f3f, 0xdeb83f3f, 0xdfb83f3f, + 0xe0b83f3f, 0xe1b83f3f, 0xe2b83f3f, 0xe3b83f3f, 0xe4b83f3f, 0xe5b83f3f, 0xe6b83f3f, 0xe7b83f3f, + 0xe8b83f3f, 0xe9b83f3f, 0xeab83f3f, 0xebb83f3f, 0xecb83f3f, 0xedb83f3f, 0xeeb83f3f, 0xefb83f3f, + 0xf0b83f3f, 0xf1b83f3f, 0xf2b83f3f, 0xf3b83f3f, 0xf4b83f3f, 0xf5b83f3f, 0xf6b83f3f, 0xf7b83f3f, + 0xf8b83f3f, 0xf9b83f3f, 0xfab83f3f, 0xfbb83f3f, 0xfcb83f3f, 0xfdb83f3f, 0xfeb83f3f, 0xffb83f3f, + 0x02a90202, 0x02a94302, 0x02a98402, 0x02a9c502, 0x03a90202, 0x03a94302, 0x03a98402, 0x03a9c502, + 0x04a90202, 0x04a94302, 0x04a98402, 0x04a9c502, 0x05a90202, 0x05a94302, 0x05a98402, 0x05a9c502, + 0x06a90202, 0x06a94302, 0x06a98402, 0x06a9c502, 0x07a90202, 0x07a94302, 0x07a98402, 0x07a9c502, + 0x08a90202, 0x08a94302, 0x08a98402, 0x08a9c502, 0x09a90202, 0x09a94302, 0x09a98402, 0x09a9c502, + 0x0aa90202, 0x0aa94302, 0x0aa98402, 0x0aa9c502, 0x0ba90202, 0x0ba94302, 0x0ba98402, 0x0ba9c502, + 0x0ca90202, 0x0ca94302, 0x0ca98402, 0x0ca9c502, 0x0da90202, 0x0da94302, 0x0da98402, 0x0da9c502, + 0x0ea90202, 0x0ea94302, 0x0ea98402, 0x0ea9c502, 0x0fa90202, 0x0fa94302, 0x0fa98402, 0x0fa9c502, + 0x10a90202, 0x10a94302, 0x10a98402, 0x10a9c502, 0x11a90202, 0x11a94302, 0x11a98402, 0x11a9c502, + 0x12a90202, 0x12a94302, 0x12a98402, 0x12a9c502, 0x13a90202, 0x13a94302, 0x13a98402, 0x13a9c502, + 0x14a90202, 0x14a94302, 0x14a98402, 0x14a9c502, 0x15a90202, 0x15a94302, 0x15a98402, 0x15a9c502, + 0x16a90202, 0x16a94302, 0x16a98402, 0x16a9c502, 0x17a90202, 0x17a94302, 0x17a98402, 0x17a9c502, + 0x18a90202, 0x18a94302, 0x18a98402, 0x18a9c502, 0x19a90202, 0x19a94302, 0x19a98402, 0x19a9c502, + 0x1aa90202, 0x1aa94302, 0x1aa98402, 0x1aa9c502, 0x1ba90202, 0x1ba94302, 0x1ba98402, 0x1ba9c502, + 0x1ca90202, 0x1ca94302, 0x1ca98402, 0x1ca9c502, 0x1da90202, 0x1da94302, 0x1da98402, 0x1da9c502, + 0x1ea90202, 0x1ea94302, 0x1ea98402, 0x1ea9c502, 0x1fa90202, 0x1fa94302, 0x1fa98402, 0x1fa9c502, + 0x20a90202, 0x20a94302, 0x20a98402, 0x20a9c502, 0x21a90202, 0x21a94302, 0x21a98402, 0x21a9c502, + 0x22a90202, 0x22a94302, 0x22a98402, 0x22a9c502, 0x23a90202, 0x23a94302, 0x23a98402, 0x23a9c502, + 0x24a90202, 0x24a94302, 0x24a98402, 0x24a9c502, 0x25a90202, 0x25a94302, 0x25a98402, 0x25a9c502, + 0x26a90202, 0x26a94302, 0x26a98402, 0x26a9c502, 0x27a90202, 0x27a94302, 0x27a98402, 0x27a9c502, + 0x28a90202, 0x28a94302, 0x28a98402, 0x28a9c502, 0x29a90202, 0x29a94302, 0x29a98402, 0x29a9c502, + 0x2aa90202, 0x2aa94302, 0x2aa98402, 0x2aa9c502, 0x2ba90202, 0x2ba94302, 0x2ba98402, 0x2ba9c502, + 0x2ca90202, 0x2ca94302, 0x2ca98402, 0x2ca9c502, 0x2da90202, 0x2da94302, 0x2da98402, 0x2da9c502, + 0x2ea90202, 0x2ea94302, 0x2ea98402, 0x2ea9c502, 0x2fa90202, 0x2fa94302, 0x2fa98402, 0x2fa9c502, + 0x30a90202, 0x30a94302, 0x30a98402, 0x30a9c502, 0x31a90202, 0x31a94302, 0x31a98402, 0x31a9c502, + 0x32a90202, 0x32a94302, 0x32a98402, 0x32a9c502, 0x33a90202, 0x33a94302, 0x33a98402, 0x33a9c502, + 0x34a90202, 0x34a94302, 0x34a98402, 0x34a9c502, 0x35a90202, 0x35a94302, 0x35a98402, 0x35a9c502, + 0x36a90202, 0x36a94302, 0x36a98402, 0x36a9c502, 0x37a90202, 0x37a94302, 0x37a98402, 0x37a9c502, + 0x38a90202, 0x38a94302, 0x38a98402, 0x38a9c502, 0x39a90202, 0x39a94302, 0x39a98402, 0x39a9c502, + 0x3aa90202, 0x3aa94302, 0x3aa98402, 0x3aa9c502, 0x3ba90202, 0x3ba94302, 0x3ba98402, 0x3ba9c502, + 0x3ca90202, 0x3ca94302, 0x3ca98402, 0x3ca9c502, 0x3da90202, 0x3da94302, 0x3da98402, 0x3da9c502, + 0x3ea90202, 0x3ea94302, 0x3ea98402, 0x3ea9c502, 0x3fa90202, 0x3fa94302, 0x3fa98402, 0x3fa9c502, + 0x40a90202, 0x40a94302, 0x40a98402, 0x40a9c502, 0x41a90202, 0x41a94302, 0x41a98402, 0x41a9c502, + 0x42a90202, 0x42a94302, 0x42a98402, 0x42a9c502, 0x43a90202, 0x43a94302, 0x43a98402, 0x43a9c502, + 0x44a90202, 0x44a94302, 0x44a98402, 0x44a9c502, 0x45a90202, 0x45a94302, 0x45a98402, 0x45a9c502, + 0x46a90202, 0x46a94302, 0x46a98402, 0x46a9c502, 0x47a90202, 0x47a94302, 0x47a98402, 0x47a9c502, + 0x48a90202, 0x48a94302, 0x48a98402, 0x48a9c502, 0x49a90202, 0x49a94302, 0x49a98402, 0x49a9c502, + 0x4aa90202, 0x4aa94302, 0x4aa98402, 0x4aa9c502, 0x4ba90202, 0x4ba94302, 0x4ba98402, 0x4ba9c502, + 0x4ca90202, 0x4ca94302, 0x4ca98402, 0x4ca9c502, 0x4da90202, 0x4da94302, 0x4da98402, 0x4da9c502, + 0x4ea90202, 0x4ea94302, 0x4ea98402, 0x4ea9c502, 0x4fa90202, 0x4fa94302, 0x4fa98402, 0x4fa9c502, + 0x50a90202, 0x50a94302, 0x50a98402, 0x50a9c502, 0x51a90202, 0x51a94302, 0x51a98402, 0x51a9c502, + 0x52a90202, 0x52a94302, 0x52a98402, 0x52a9c502, 0x53a90202, 0x53a94302, 0x53a98402, 0x53a9c502, + 0x54a90202, 0x54a94302, 0x54a98402, 0x54a9c502, 0x55a90202, 0x55a94302, 0x55a98402, 0x55a9c502, + 0x56a90202, 0x56a94302, 0x56a98402, 0x56a9c502, 0x57a90202, 0x57a94302, 0x57a98402, 0x57a9c502, + 0x58a90202, 0x58a94302, 0x58a98402, 0x58a9c502, 0x59a90202, 0x59a94302, 0x59a98402, 0x59a9c502, + 0x5aa90202, 0x5aa94302, 0x5aa98402, 0x5aa9c502, 0x5ba90202, 0x5ba94302, 0x5ba98402, 0x5ba9c502, + 0x5ca90202, 0x5ca94302, 0x5ca98402, 0x5ca9c502, 0x5da90202, 0x5da94302, 0x5da98402, 0x5da9c502, + 0x5ea90202, 0x5ea94302, 0x5ea98402, 0x5ea9c502, 0x5fa90202, 0x5fa94302, 0x5fa98402, 0x5fa9c502, + 0x60a90202, 0x60a94302, 0x60a98402, 0x60a9c502, 0x61a90202, 0x61a94302, 0x61a98402, 0x61a9c502, + 0x62a90202, 0x62a94302, 0x62a98402, 0x62a9c502, 0x63a90202, 0x63a94302, 0x63a98402, 0x63a9c502, + 0x64a90202, 0x64a94302, 0x64a98402, 0x64a9c502, 0x65a90202, 0x65a94302, 0x65a98402, 0x65a9c502, + 0x66a90202, 0x66a94302, 0x66a98402, 0x66a9c502, 0x67a90202, 0x67a94302, 0x67a98402, 0x67a9c502, + 0x68a90202, 0x68a94302, 0x68a98402, 0x68a9c502, 0x69a90202, 0x69a94302, 0x69a98402, 0x69a9c502, + 0x6aa90202, 0x6aa94302, 0x6aa98402, 0x6aa9c502, 0x6ba90202, 0x6ba94302, 0x6ba98402, 0x6ba9c502, + 0x6ca90202, 0x6ca94302, 0x6ca98402, 0x6ca9c502, 0x6da90202, 0x6da94302, 0x6da98402, 0x6da9c502, + 0x6ea90202, 0x6ea94302, 0x6ea98402, 0x6ea9c502, 0x6fa90202, 0x6fa94302, 0x6fa98402, 0x6fa9c502, + 0x70a90202, 0x70a94302, 0x70a98402, 0x70a9c502, 0x71a90202, 0x71a94302, 0x71a98402, 0x71a9c502, + 0x72a90202, 0x72a94302, 0x72a98402, 0x72a9c502, 0x73a90202, 0x73a94302, 0x73a98402, 0x73a9c502, + 0x74a90202, 0x74a94302, 0x74a98402, 0x74a9c502, 0x75a90202, 0x75a94302, 0x75a98402, 0x75a9c502, + 0x76a90202, 0x76a94302, 0x76a98402, 0x76a9c502, 0x77a90202, 0x77a94302, 0x77a98402, 0x77a9c502, + 0x78a90202, 0x78a94302, 0x78a98402, 0x78a9c502, 0x79a90202, 0x79a94302, 0x79a98402, 0x79a9c502, + 0x7aa90202, 0x7aa94302, 0x7aa98402, 0x7aa9c502, 0x7ba90202, 0x7ba94302, 0x7ba98402, 0x7ba9c502, + 0x7ca90202, 0x7ca94302, 0x7ca98402, 0x7ca9c502, 0x7da90202, 0x7da94302, 0x7da98402, 0x7da9c502, + 0x7ea90202, 0x7ea94302, 0x7ea98402, 0x7ea9c502, 0x7fa90202, 0x7fa94302, 0x7fa98402, 0x7fa9c502, + 0x80a90202, 0x80a94302, 0x80a98402, 0x80a9c502, 0x81a90202, 0x81a94302, 0x81a98402, 0x81a9c502, + 0x82a90202, 0x82a94302, 0x82a98402, 0x82a9c502, 0x83a90202, 0x83a94302, 0x83a98402, 0x83a9c502, + 0x84a90202, 0x84a94302, 0x84a98402, 0x84a9c502, 0x85a90202, 0x85a94302, 0x85a98402, 0x85a9c502, + 0x86a90202, 0x86a94302, 0x86a98402, 0x86a9c502, 0x87a90202, 0x87a94302, 0x87a98402, 0x87a9c502, + 0x88a90202, 0x88a94302, 0x88a98402, 0x88a9c502, 0x89a90202, 0x89a94302, 0x89a98402, 0x89a9c502, + 0x8aa90202, 0x8aa94302, 0x8aa98402, 0x8aa9c502, 0x8ba90202, 0x8ba94302, 0x8ba98402, 0x8ba9c502, + 0x8ca90202, 0x8ca94302, 0x8ca98402, 0x8ca9c502, 0x8da90202, 0x8da94302, 0x8da98402, 0x8da9c502, + 0x8ea90202, 0x8ea94302, 0x8ea98402, 0x8ea9c502, 0x8fa90202, 0x8fa94302, 0x8fa98402, 0x8fa9c502, + 0x90a90202, 0x90a94302, 0x90a98402, 0x90a9c502, 0x91a90202, 0x91a94302, 0x91a98402, 0x91a9c502, + 0x92a90202, 0x92a94302, 0x92a98402, 0x92a9c502, 0x93a90202, 0x93a94302, 0x93a98402, 0x93a9c502, + 0x94a90202, 0x94a94302, 0x94a98402, 0x94a9c502, 0x95a90202, 0x95a94302, 0x95a98402, 0x95a9c502, + 0x96a90202, 0x96a94302, 0x96a98402, 0x96a9c502, 0x97a90202, 0x97a94302, 0x97a98402, 0x97a9c502, + 0x98a90202, 0x98a94302, 0x98a98402, 0x98a9c502, 0x99a90202, 0x99a94302, 0x99a98402, 0x99a9c502, + 0x9aa90202, 0x9aa94302, 0x9aa98402, 0x9aa9c502, 0x9ba90202, 0x9ba94302, 0x9ba98402, 0x9ba9c502, + 0x9ca90202, 0x9ca94302, 0x9ca98402, 0x9ca9c502, 0x9da90202, 0x9da94302, 0x9da98402, 0x9da9c502, + 0x9ea90202, 0x9ea94302, 0x9ea98402, 0x9ea9c502, 0x9fa90202, 0x9fa94302, 0x9fa98402, 0x9fa9c502, + 0xa0a90202, 0xa0a94302, 0xa0a98402, 0xa0a9c502, 0xa1a90202, 0xa1a94302, 0xa1a98402, 0xa1a9c502, + 0xa2a90202, 0xa2a94302, 0xa2a98402, 0xa2a9c502, 0xa3a90202, 0xa3a94302, 0xa3a98402, 0xa3a9c502, + 0xa4a90202, 0xa4a94302, 0xa4a98402, 0xa4a9c502, 0xa5a90202, 0xa5a94302, 0xa5a98402, 0xa5a9c502, + 0xa6a90202, 0xa6a94302, 0xa6a98402, 0xa6a9c502, 0xa7a90202, 0xa7a94302, 0xa7a98402, 0xa7a9c502, + 0xa8a90202, 0xa8a94302, 0xa8a98402, 0xa8a9c502, 0xa9a90202, 0xa9a94302, 0xa9a98402, 0xa9a9c502, + 0xaaa90202, 0xaaa94302, 0xaaa98402, 0xaaa9c502, 0xaba90202, 0xaba94302, 0xaba98402, 0xaba9c502, + 0xaca90202, 0xaca94302, 0xaca98402, 0xaca9c502, 0xada90202, 0xada94302, 0xada98402, 0xada9c502, + 0xaea90202, 0xaea94302, 0xaea98402, 0xaea9c502, 0xafa90202, 0xafa94302, 0xafa98402, 0xafa9c502, + 0xb0a90202, 0xb0a94302, 0xb0a98402, 0xb0a9c502, 0xb1a90202, 0xb1a94302, 0xb1a98402, 0xb1a9c502, + 0xb2a90202, 0xb2a94302, 0xb2a98402, 0xb2a9c502, 0xb3a90202, 0xb3a94302, 0xb3a98402, 0xb3a9c502, + 0xb4a90202, 0xb4a94302, 0xb4a98402, 0xb4a9c502, 0xb5a90202, 0xb5a94302, 0xb5a98402, 0xb5a9c502, + 0xb6a90202, 0xb6a94302, 0xb6a98402, 0xb6a9c502, 0xb7a90202, 0xb7a94302, 0xb7a98402, 0xb7a9c502, + 0xb8a90202, 0xb8a94302, 0xb8a98402, 0xb8a9c502, 0xb9a90202, 0xb9a94302, 0xb9a98402, 0xb9a9c502, + 0xbaa90202, 0xbaa94302, 0xbaa98402, 0xbaa9c502, 0xbba90202, 0xbba94302, 0xbba98402, 0xbba9c502, + 0xbca90202, 0xbca94302, 0xbca98402, 0xbca9c502, 0xbda90202, 0xbda94302, 0xbda98402, 0xbda9c502, + 0xbea90202, 0xbea94302, 0xbea98402, 0xbea9c502, 0xbfa90202, 0xbfa94302, 0xbfa98402, 0xbfa9c502, + 0xc0a90202, 0xc0a94302, 0xc0a98402, 0xc0a9c502, 0xc1a90202, 0xc1a94302, 0xc1a98402, 0xc1a9c502, + 0xc2a90202, 0xc2a94302, 0xc2a98402, 0xc2a9c502, 0xc3a90202, 0xc3a94302, 0xc3a98402, 0xc3a9c502, + 0xc4a90202, 0xc4a94302, 0xc4a98402, 0xc4a9c502, 0xc5a90202, 0xc5a94302, 0xc5a98402, 0xc5a9c502, + 0xc6a90202, 0xc6a94302, 0xc6a98402, 0xc6a9c502, 0xc7a90202, 0xc7a94302, 0xc7a98402, 0xc7a9c502, + 0xc8a90202, 0xc8a94302, 0xc8a98402, 0xc8a9c502, 0xc9a90202, 0xc9a94302, 0xc9a98402, 0xc9a9c502, + 0xcaa90202, 0xcaa94302, 0xcaa98402, 0xcaa9c502, 0xcba90202, 0xcba94302, 0xcba98402, 0xcba9c502, + 0xcca90202, 0xcca94302, 0xcca98402, 0xcca9c502, 0xcda90202, 0xcda94302, 0xcda98402, 0xcda9c502, + 0xcea90202, 0xcea94302, 0xcea98402, 0xcea9c502, 0xcfa90202, 0xcfa94302, 0xcfa98402, 0xcfa9c502, + 0xd0a90202, 0xd0a94302, 0xd0a98402, 0xd0a9c502, 0xd1a90202, 0xd1a94302, 0xd1a98402, 0xd1a9c502, + 0xd2a90202, 0xd2a94302, 0xd2a98402, 0xd2a9c502, 0xd3a90202, 0xd3a94302, 0xd3a98402, 0xd3a9c502, + 0xd4a90202, 0xd4a94302, 0xd4a98402, 0xd4a9c502, 0xd5a90202, 0xd5a94302, 0xd5a98402, 0xd5a9c502, + 0xd6a90202, 0xd6a94302, 0xd6a98402, 0xd6a9c502, 0xd7a90202, 0xd7a94302, 0xd7a98402, 0xd7a9c502, + 0xd8a90202, 0xd8a94302, 0xd8a98402, 0xd8a9c502, 0xd9a90202, 0xd9a94302, 0xd9a98402, 0xd9a9c502, + 0xdaa90202, 0xdaa94302, 0xdaa98402, 0xdaa9c502, 0xdba90202, 0xdba94302, 0xdba98402, 0xdba9c502, + 0xdca90202, 0xdca94302, 0xdca98402, 0xdca9c502, 0xdda90202, 0xdda94302, 0xdda98402, 0xdda9c502, + 0xdea90202, 0xdea94302, 0xdea98402, 0xdea9c502, 0xdfa90202, 0xdfa94302, 0xdfa98402, 0xdfa9c502, + 0xe0a90202, 0xe0a94302, 0xe0a98402, 0xe0a9c502, 0xe1a90202, 0xe1a94302, 0xe1a98402, 0xe1a9c502, + 0xe2a90202, 0xe2a94302, 0xe2a98402, 0xe2a9c502, 0xe3a90202, 0xe3a94302, 0xe3a98402, 0xe3a9c502, + 0xe4a90202, 0xe4a94302, 0xe4a98402, 0xe4a9c502, 0xe5a90202, 0xe5a94302, 0xe5a98402, 0xe5a9c502, + 0xe6a90202, 0xe6a94302, 0xe6a98402, 0xe6a9c502, 0xe7a90202, 0xe7a94302, 0xe7a98402, 0xe7a9c502, + 0xe8a90202, 0xe8a94302, 0xe8a98402, 0xe8a9c502, 0xe9a90202, 0xe9a94302, 0xe9a98402, 0xe9a9c502, + 0xeaa90202, 0xeaa94302, 0xeaa98402, 0xeaa9c502, 0xeba90202, 0xeba94302, 0xeba98402, 0xeba9c502, + 0xeca90202, 0xeca94302, 0xeca98402, 0xeca9c502, 0xeda90202, 0xeda94302, 0xeda98402, 0xeda9c502, + 0xeea90202, 0xeea94302, 0xeea98402, 0xeea9c502, 0xefa90202, 0xefa94302, 0xefa98402, 0xefa9c502, + 0xf0a90202, 0xf0a94302, 0xf0a98402, 0xf0a9c502, 0xf1a90202, 0xf1a94302, 0xf1a98402, 0xf1a9c502, + 0xf2a90202, 0xf2a94302, 0xf2a98402, 0xf2a9c502, 0xf3a90202, 0xf3a94302, 0xf3a98402, 0xf3a9c502, + 0xf4a90202, 0xf4a94302, 0xf4a98402, 0xf4a9c502, 0xf5a90202, 0xf5a94302, 0xf5a98402, 0xf5a9c502, + 0xf6a90202, 0xf6a94302, 0xf6a98402, 0xf6a9c502, 0xf7a90202, 0xf7a94302, 0xf7a98402, 0xf7a9c502, + 0xf8a90202, 0xf8a94302, 0xf8a98402, 0xf8a9c502, 0xf9a90202, 0xf9a94302, 0xf9a98402, 0xf9a9c502, + 0xfaa90202, 0xfaa94302, 0xfaa98402, 0xfaa9c502, 0xfba90202, 0xfba94302, 0xfba98402, 0xfba9c502, + 0xfca90202, 0xfca94302, 0xfca98402, 0xfca9c502, 0xfda90202, 0xfda94302, 0xfda98402, 0xfda9c502, + 0xfea90202, 0xfea94302, 0xfea98402, 0xfea9c502, 0xffa90202, 0xffa94302, 0xffa98402, 0xffa9c502, + 0x02aa0202, 0x02aa4302, 0x02aa8402, 0x02aac502, 0x03aa0202, 0x03aa4302, 0x03aa8402, 0x03aac502, + 0x04aa0202, 0x04aa4302, 0x04aa8402, 0x04aac502, 0x05aa0202, 0x05aa4302, 0x05aa8402, 0x05aac502, + 0x06aa0202, 0x06aa4302, 0x06aa8402, 0x06aac502, 0x07aa0202, 0x07aa4302, 0x07aa8402, 0x07aac502, + 0x08aa0202, 0x08aa4302, 0x08aa8402, 0x08aac502, 0x09aa0202, 0x09aa4302, 0x09aa8402, 0x09aac502, + 0x0aaa0202, 0x0aaa4302, 0x0aaa8402, 0x0aaac502, 0x0baa0202, 0x0baa4302, 0x0baa8402, 0x0baac502, + 0x0caa0202, 0x0caa4302, 0x0caa8402, 0x0caac502, 0x0daa0202, 0x0daa4302, 0x0daa8402, 0x0daac502, + 0x0eaa0202, 0x0eaa4302, 0x0eaa8402, 0x0eaac502, 0x0faa0202, 0x0faa4302, 0x0faa8402, 0x0faac502, + 0x10aa0202, 0x10aa4302, 0x10aa8402, 0x10aac502, 0x11aa0202, 0x11aa4302, 0x11aa8402, 0x11aac502, + 0x12aa0202, 0x12aa4302, 0x12aa8402, 0x12aac502, 0x13aa0202, 0x13aa4302, 0x13aa8402, 0x13aac502, + 0x14aa0202, 0x14aa4302, 0x14aa8402, 0x14aac502, 0x15aa0202, 0x15aa4302, 0x15aa8402, 0x15aac502, + 0x16aa0202, 0x16aa4302, 0x16aa8402, 0x16aac502, 0x17aa0202, 0x17aa4302, 0x17aa8402, 0x17aac502, + 0x18aa0202, 0x18aa4302, 0x18aa8402, 0x18aac502, 0x19aa0202, 0x19aa4302, 0x19aa8402, 0x19aac502, + 0x1aaa0202, 0x1aaa4302, 0x1aaa8402, 0x1aaac502, 0x1baa0202, 0x1baa4302, 0x1baa8402, 0x1baac502, + 0x1caa0202, 0x1caa4302, 0x1caa8402, 0x1caac502, 0x1daa0202, 0x1daa4302, 0x1daa8402, 0x1daac502, + 0x1eaa0202, 0x1eaa4302, 0x1eaa8402, 0x1eaac502, 0x1faa0202, 0x1faa4302, 0x1faa8402, 0x1faac502, + 0x20aa0202, 0x20aa4302, 0x20aa8402, 0x20aac502, 0x21aa0202, 0x21aa4302, 0x21aa8402, 0x21aac502, + 0x22aa0202, 0x22aa4302, 0x22aa8402, 0x22aac502, 0x23aa0202, 0x23aa4302, 0x23aa8402, 0x23aac502, + 0x24aa0202, 0x24aa4302, 0x24aa8402, 0x24aac502, 0x25aa0202, 0x25aa4302, 0x25aa8402, 0x25aac502, + 0x26aa0202, 0x26aa4302, 0x26aa8402, 0x26aac502, 0x27aa0202, 0x27aa4302, 0x27aa8402, 0x27aac502, + 0x28aa0202, 0x28aa4302, 0x28aa8402, 0x28aac502, 0x29aa0202, 0x29aa4302, 0x29aa8402, 0x29aac502, + 0x2aaa0202, 0x2aaa4302, 0x2aaa8402, 0x2aaac502, 0x2baa0202, 0x2baa4302, 0x2baa8402, 0x2baac502, + 0x2caa0202, 0x2caa4302, 0x2caa8402, 0x2caac502, 0x2daa0202, 0x2daa4302, 0x2daa8402, 0x2daac502, + 0x2eaa0202, 0x2eaa4302, 0x2eaa8402, 0x2eaac502, 0x2faa0202, 0x2faa4302, 0x2faa8402, 0x2faac502, + 0x30aa0202, 0x30aa4302, 0x30aa8402, 0x30aac502, 0x31aa0202, 0x31aa4302, 0x31aa8402, 0x31aac502, + 0x32aa0202, 0x32aa4302, 0x32aa8402, 0x32aac502, 0x33aa0202, 0x33aa4302, 0x33aa8402, 0x33aac502, + 0x34aa0202, 0x34aa4302, 0x34aa8402, 0x34aac502, 0x35aa0202, 0x35aa4302, 0x35aa8402, 0x35aac502, + 0x36aa0202, 0x36aa4302, 0x36aa8402, 0x36aac502, 0x37aa0202, 0x37aa4302, 0x37aa8402, 0x37aac502, + 0x38aa0202, 0x38aa4302, 0x38aa8402, 0x38aac502, 0x39aa0202, 0x39aa4302, 0x39aa8402, 0x39aac502, + 0x3aaa0202, 0x3aaa4302, 0x3aaa8402, 0x3aaac502, 0x3baa0202, 0x3baa4302, 0x3baa8402, 0x3baac502, + 0x3caa0202, 0x3caa4302, 0x3caa8402, 0x3caac502, 0x3daa0202, 0x3daa4302, 0x3daa8402, 0x3daac502, + 0x3eaa0202, 0x3eaa4302, 0x3eaa8402, 0x3eaac502, 0x3faa0202, 0x3faa4302, 0x3faa8402, 0x3faac502, + 0x40aa0202, 0x40aa4302, 0x40aa8402, 0x40aac502, 0x41aa0202, 0x41aa4302, 0x41aa8402, 0x41aac502, + 0x42aa0202, 0x42aa4302, 0x42aa8402, 0x42aac502, 0x43aa0202, 0x43aa4302, 0x43aa8402, 0x43aac502, + 0x44aa0202, 0x44aa4302, 0x44aa8402, 0x44aac502, 0x45aa0202, 0x45aa4302, 0x45aa8402, 0x45aac502, + 0x46aa0202, 0x46aa4302, 0x46aa8402, 0x46aac502, 0x47aa0202, 0x47aa4302, 0x47aa8402, 0x47aac502, + 0x48aa0202, 0x48aa4302, 0x48aa8402, 0x48aac502, 0x49aa0202, 0x49aa4302, 0x49aa8402, 0x49aac502, + 0x4aaa0202, 0x4aaa4302, 0x4aaa8402, 0x4aaac502, 0x4baa0202, 0x4baa4302, 0x4baa8402, 0x4baac502, + 0x4caa0202, 0x4caa4302, 0x4caa8402, 0x4caac502, 0x4daa0202, 0x4daa4302, 0x4daa8402, 0x4daac502, + 0x4eaa0202, 0x4eaa4302, 0x4eaa8402, 0x4eaac502, 0x4faa0202, 0x4faa4302, 0x4faa8402, 0x4faac502, + 0x50aa0202, 0x50aa4302, 0x50aa8402, 0x50aac502, 0x51aa0202, 0x51aa4302, 0x51aa8402, 0x51aac502, + 0x52aa0202, 0x52aa4302, 0x52aa8402, 0x52aac502, 0x53aa0202, 0x53aa4302, 0x53aa8402, 0x53aac502, + 0x54aa0202, 0x54aa4302, 0x54aa8402, 0x54aac502, 0x55aa0202, 0x55aa4302, 0x55aa8402, 0x55aac502, + 0x56aa0202, 0x56aa4302, 0x56aa8402, 0x56aac502, 0x57aa0202, 0x57aa4302, 0x57aa8402, 0x57aac502, + 0x58aa0202, 0x58aa4302, 0x58aa8402, 0x58aac502, 0x59aa0202, 0x59aa4302, 0x59aa8402, 0x59aac502, + 0x5aaa0202, 0x5aaa4302, 0x5aaa8402, 0x5aaac502, 0x5baa0202, 0x5baa4302, 0x5baa8402, 0x5baac502, + 0x5caa0202, 0x5caa4302, 0x5caa8402, 0x5caac502, 0x5daa0202, 0x5daa4302, 0x5daa8402, 0x5daac502, + 0x5eaa0202, 0x5eaa4302, 0x5eaa8402, 0x5eaac502, 0x5faa0202, 0x5faa4302, 0x5faa8402, 0x5faac502, + 0x60aa0202, 0x60aa4302, 0x60aa8402, 0x60aac502, 0x61aa0202, 0x61aa4302, 0x61aa8402, 0x61aac502, + 0x62aa0202, 0x62aa4302, 0x62aa8402, 0x62aac502, 0x63aa0202, 0x63aa4302, 0x63aa8402, 0x63aac502, + 0x64aa0202, 0x64aa4302, 0x64aa8402, 0x64aac502, 0x65aa0202, 0x65aa4302, 0x65aa8402, 0x65aac502, + 0x66aa0202, 0x66aa4302, 0x66aa8402, 0x66aac502, 0x67aa0202, 0x67aa4302, 0x67aa8402, 0x67aac502, + 0x68aa0202, 0x68aa4302, 0x68aa8402, 0x68aac502, 0x69aa0202, 0x69aa4302, 0x69aa8402, 0x69aac502, + 0x6aaa0202, 0x6aaa4302, 0x6aaa8402, 0x6aaac502, 0x6baa0202, 0x6baa4302, 0x6baa8402, 0x6baac502, + 0x6caa0202, 0x6caa4302, 0x6caa8402, 0x6caac502, 0x6daa0202, 0x6daa4302, 0x6daa8402, 0x6daac502, + 0x6eaa0202, 0x6eaa4302, 0x6eaa8402, 0x6eaac502, 0x6faa0202, 0x6faa4302, 0x6faa8402, 0x6faac502, + 0x70aa0202, 0x70aa4302, 0x70aa8402, 0x70aac502, 0x71aa0202, 0x71aa4302, 0x71aa8402, 0x71aac502, + 0x72aa0202, 0x72aa4302, 0x72aa8402, 0x72aac502, 0x73aa0202, 0x73aa4302, 0x73aa8402, 0x73aac502, + 0x74aa0202, 0x74aa4302, 0x74aa8402, 0x74aac502, 0x75aa0202, 0x75aa4302, 0x75aa8402, 0x75aac502, + 0x76aa0202, 0x76aa4302, 0x76aa8402, 0x76aac502, 0x77aa0202, 0x77aa4302, 0x77aa8402, 0x77aac502, + 0x78aa0202, 0x78aa4302, 0x78aa8402, 0x78aac502, 0x79aa0202, 0x79aa4302, 0x79aa8402, 0x79aac502, + 0x7aaa0202, 0x7aaa4302, 0x7aaa8402, 0x7aaac502, 0x7baa0202, 0x7baa4302, 0x7baa8402, 0x7baac502, + 0x7caa0202, 0x7caa4302, 0x7caa8402, 0x7caac502, 0x7daa0202, 0x7daa4302, 0x7daa8402, 0x7daac502, + 0x7eaa0202, 0x7eaa4302, 0x7eaa8402, 0x7eaac502, 0x7faa0202, 0x7faa4302, 0x7faa8402, 0x7faac502, + 0x80aa0202, 0x80aa4302, 0x80aa8402, 0x80aac502, 0x81aa0202, 0x81aa4302, 0x81aa8402, 0x81aac502, + 0x82aa0202, 0x82aa4302, 0x82aa8402, 0x82aac502, 0x83aa0202, 0x83aa4302, 0x83aa8402, 0x83aac502, + 0x84aa0202, 0x84aa4302, 0x84aa8402, 0x84aac502, 0x85aa0202, 0x85aa4302, 0x85aa8402, 0x85aac502, + 0x86aa0202, 0x86aa4302, 0x86aa8402, 0x86aac502, 0x87aa0202, 0x87aa4302, 0x87aa8402, 0x87aac502, + 0x88aa0202, 0x88aa4302, 0x88aa8402, 0x88aac502, 0x89aa0202, 0x89aa4302, 0x89aa8402, 0x89aac502, + 0x8aaa0202, 0x8aaa4302, 0x8aaa8402, 0x8aaac502, 0x8baa0202, 0x8baa4302, 0x8baa8402, 0x8baac502, + 0x8caa0202, 0x8caa4302, 0x8caa8402, 0x8caac502, 0x8daa0202, 0x8daa4302, 0x8daa8402, 0x8daac502, + 0x8eaa0202, 0x8eaa4302, 0x8eaa8402, 0x8eaac502, 0x8faa0202, 0x8faa4302, 0x8faa8402, 0x8faac502, + 0x90aa0202, 0x90aa4302, 0x90aa8402, 0x90aac502, 0x91aa0202, 0x91aa4302, 0x91aa8402, 0x91aac502, + 0x92aa0202, 0x92aa4302, 0x92aa8402, 0x92aac502, 0x93aa0202, 0x93aa4302, 0x93aa8402, 0x93aac502, + 0x94aa0202, 0x94aa4302, 0x94aa8402, 0x94aac502, 0x95aa0202, 0x95aa4302, 0x95aa8402, 0x95aac502, + 0x96aa0202, 0x96aa4302, 0x96aa8402, 0x96aac502, 0x97aa0202, 0x97aa4302, 0x97aa8402, 0x97aac502, + 0x98aa0202, 0x98aa4302, 0x98aa8402, 0x98aac502, 0x99aa0202, 0x99aa4302, 0x99aa8402, 0x99aac502, + 0x9aaa0202, 0x9aaa4302, 0x9aaa8402, 0x9aaac502, 0x9baa0202, 0x9baa4302, 0x9baa8402, 0x9baac502, + 0x9caa0202, 0x9caa4302, 0x9caa8402, 0x9caac502, 0x9daa0202, 0x9daa4302, 0x9daa8402, 0x9daac502, + 0x9eaa0202, 0x9eaa4302, 0x9eaa8402, 0x9eaac502, 0x9faa0202, 0x9faa4302, 0x9faa8402, 0x9faac502, + 0xa0aa0202, 0xa0aa4302, 0xa0aa8402, 0xa0aac502, 0xa1aa0202, 0xa1aa4302, 0xa1aa8402, 0xa1aac502, + 0xa2aa0202, 0xa2aa4302, 0xa2aa8402, 0xa2aac502, 0xa3aa0202, 0xa3aa4302, 0xa3aa8402, 0xa3aac502, + 0xa4aa0202, 0xa4aa4302, 0xa4aa8402, 0xa4aac502, 0xa5aa0202, 0xa5aa4302, 0xa5aa8402, 0xa5aac502, + 0xa6aa0202, 0xa6aa4302, 0xa6aa8402, 0xa6aac502, 0xa7aa0202, 0xa7aa4302, 0xa7aa8402, 0xa7aac502, + 0xa8aa0202, 0xa8aa4302, 0xa8aa8402, 0xa8aac502, 0xa9aa0202, 0xa9aa4302, 0xa9aa8402, 0xa9aac502, + 0xaaaa0202, 0xaaaa4302, 0xaaaa8402, 0xaaaac502, 0xabaa0202, 0xabaa4302, 0xabaa8402, 0xabaac502, + 0xacaa0202, 0xacaa4302, 0xacaa8402, 0xacaac502, 0xadaa0202, 0xadaa4302, 0xadaa8402, 0xadaac502, + 0xaeaa0202, 0xaeaa4302, 0xaeaa8402, 0xaeaac502, 0xafaa0202, 0xafaa4302, 0xafaa8402, 0xafaac502, + 0xb0aa0202, 0xb0aa4302, 0xb0aa8402, 0xb0aac502, 0xb1aa0202, 0xb1aa4302, 0xb1aa8402, 0xb1aac502, + 0xb2aa0202, 0xb2aa4302, 0xb2aa8402, 0xb2aac502, 0xb3aa0202, 0xb3aa4302, 0xb3aa8402, 0xb3aac502, + 0xb4aa0202, 0xb4aa4302, 0xb4aa8402, 0xb4aac502, 0xb5aa0202, 0xb5aa4302, 0xb5aa8402, 0xb5aac502, + 0xb6aa0202, 0xb6aa4302, 0xb6aa8402, 0xb6aac502, 0xb7aa0202, 0xb7aa4302, 0xb7aa8402, 0xb7aac502, + 0xb8aa0202, 0xb8aa4302, 0xb8aa8402, 0xb8aac502, 0xb9aa0202, 0xb9aa4302, 0xb9aa8402, 0xb9aac502, + 0xbaaa0202, 0xbaaa4302, 0xbaaa8402, 0xbaaac502, 0xbbaa0202, 0xbbaa4302, 0xbbaa8402, 0xbbaac502, + 0xbcaa0202, 0xbcaa4302, 0xbcaa8402, 0xbcaac502, 0xbdaa0202, 0xbdaa4302, 0xbdaa8402, 0xbdaac502, + 0xbeaa0202, 0xbeaa4302, 0xbeaa8402, 0xbeaac502, 0xbfaa0202, 0xbfaa4302, 0xbfaa8402, 0xbfaac502, + 0xc0aa0202, 0xc0aa4302, 0xc0aa8402, 0xc0aac502, 0xc1aa0202, 0xc1aa4302, 0xc1aa8402, 0xc1aac502, + 0xc2aa0202, 0xc2aa4302, 0xc2aa8402, 0xc2aac502, 0xc3aa0202, 0xc3aa4302, 0xc3aa8402, 0xc3aac502, + 0xc4aa0202, 0xc4aa4302, 0xc4aa8402, 0xc4aac502, 0xc5aa0202, 0xc5aa4302, 0xc5aa8402, 0xc5aac502, + 0xc6aa0202, 0xc6aa4302, 0xc6aa8402, 0xc6aac502, 0xc7aa0202, 0xc7aa4302, 0xc7aa8402, 0xc7aac502, + 0xc8aa0202, 0xc8aa4302, 0xc8aa8402, 0xc8aac502, 0xc9aa0202, 0xc9aa4302, 0xc9aa8402, 0xc9aac502, + 0xcaaa0202, 0xcaaa4302, 0xcaaa8402, 0xcaaac502, 0xcbaa0202, 0xcbaa4302, 0xcbaa8402, 0xcbaac502, + 0xccaa0202, 0xccaa4302, 0xccaa8402, 0xccaac502, 0xcdaa0202, 0xcdaa4302, 0xcdaa8402, 0xcdaac502, + 0xceaa0202, 0xceaa4302, 0xceaa8402, 0xceaac502, 0xcfaa0202, 0xcfaa4302, 0xcfaa8402, 0xcfaac502, + 0xd0aa0202, 0xd0aa4302, 0xd0aa8402, 0xd0aac502, 0xd1aa0202, 0xd1aa4302, 0xd1aa8402, 0xd1aac502, + 0xd2aa0202, 0xd2aa4302, 0xd2aa8402, 0xd2aac502, 0xd3aa0202, 0xd3aa4302, 0xd3aa8402, 0xd3aac502, + 0xd4aa0202, 0xd4aa4302, 0xd4aa8402, 0xd4aac502, 0xd5aa0202, 0xd5aa4302, 0xd5aa8402, 0xd5aac502, + 0xd6aa0202, 0xd6aa4302, 0xd6aa8402, 0xd6aac502, 0xd7aa0202, 0xd7aa4302, 0xd7aa8402, 0xd7aac502, + 0xd8aa0202, 0xd8aa4302, 0xd8aa8402, 0xd8aac502, 0xd9aa0202, 0xd9aa4302, 0xd9aa8402, 0xd9aac502, + 0xdaaa0202, 0xdaaa4302, 0xdaaa8402, 0xdaaac502, 0xdbaa0202, 0xdbaa4302, 0xdbaa8402, 0xdbaac502, + 0xdcaa0202, 0xdcaa4302, 0xdcaa8402, 0xdcaac502, 0xddaa0202, 0xddaa4302, 0xddaa8402, 0xddaac502, + 0xdeaa0202, 0xdeaa4302, 0xdeaa8402, 0xdeaac502, 0xdfaa0202, 0xdfaa4302, 0xdfaa8402, 0xdfaac502, + 0xe0aa0202, 0xe0aa4302, 0xe0aa8402, 0xe0aac502, 0xe1aa0202, 0xe1aa4302, 0xe1aa8402, 0xe1aac502, + 0xe2aa0202, 0xe2aa4302, 0xe2aa8402, 0xe2aac502, 0xe3aa0202, 0xe3aa4302, 0xe3aa8402, 0xe3aac502, + 0xe4aa0202, 0xe4aa4302, 0xe4aa8402, 0xe4aac502, 0xe5aa0202, 0xe5aa4302, 0xe5aa8402, 0xe5aac502, + 0xe6aa0202, 0xe6aa4302, 0xe6aa8402, 0xe6aac502, 0xe7aa0202, 0xe7aa4302, 0xe7aa8402, 0xe7aac502, + 0xe8aa0202, 0xe8aa4302, 0xe8aa8402, 0xe8aac502, 0xe9aa0202, 0xe9aa4302, 0xe9aa8402, 0xe9aac502, + 0xeaaa0202, 0xeaaa4302, 0xeaaa8402, 0xeaaac502, 0xebaa0202, 0xebaa4302, 0xebaa8402, 0xebaac502, + 0xecaa0202, 0xecaa4302, 0xecaa8402, 0xecaac502, 0xedaa0202, 0xedaa4302, 0xedaa8402, 0xedaac502, + 0xeeaa0202, 0xeeaa4302, 0xeeaa8402, 0xeeaac502, 0xefaa0202, 0xefaa4302, 0xefaa8402, 0xefaac502, + 0xf0aa0202, 0xf0aa4302, 0xf0aa8402, 0xf0aac502, 0xf1aa0202, 0xf1aa4302, 0xf1aa8402, 0xf1aac502, + 0xf2aa0202, 0xf2aa4302, 0xf2aa8402, 0xf2aac502, 0xf3aa0202, 0xf3aa4302, 0xf3aa8402, 0xf3aac502, + 0xf4aa0202, 0xf4aa4302, 0xf4aa8402, 0xf4aac502, 0xf5aa0202, 0xf5aa4302, 0xf5aa8402, 0xf5aac502, + 0xf6aa0202, 0xf6aa4302, 0xf6aa8402, 0xf6aac502, 0xf7aa0202, 0xf7aa4302, 0xf7aa8402, 0xf7aac502, + 0xf8aa0202, 0xf8aa4302, 0xf8aa8402, 0xf8aac502, 0xf9aa0202, 0xf9aa4302, 0xf9aa8402, 0xf9aac502, + 0xfaaa0202, 0xfaaa4302, 0xfaaa8402, 0xfaaac502, 0xfbaa0202, 0xfbaa4302, 0xfbaa8402, 0xfbaac502, + 0xfcaa0202, 0xfcaa4302, 0xfcaa8402, 0xfcaac502, 0xfdaa0202, 0xfdaa4302, 0xfdaa8402, 0xfdaac502, + 0xfeaa0202, 0xfeaa4302, 0xfeaa8402, 0xfeaac502, 0xffaa0202, 0xffaa4302, 0xffaa8402, 0xffaac502, + 0x02ab0202, 0x02ab4302, 0x02ab8402, 0x02abc502, 0x03ab0202, 0x03ab4302, 0x03ab8402, 0x03abc502, + 0x04ab0202, 0x04ab4302, 0x04ab8402, 0x04abc502, 0x05ab0202, 0x05ab4302, 0x05ab8402, 0x05abc502, + 0x06ab0202, 0x06ab4302, 0x06ab8402, 0x06abc502, 0x07ab0202, 0x07ab4302, 0x07ab8402, 0x07abc502, + 0x08ab0202, 0x08ab4302, 0x08ab8402, 0x08abc502, 0x09ab0202, 0x09ab4302, 0x09ab8402, 0x09abc502, + 0x0aab0202, 0x0aab4302, 0x0aab8402, 0x0aabc502, 0x0bab0202, 0x0bab4302, 0x0bab8402, 0x0babc502, + 0x0cab0202, 0x0cab4302, 0x0cab8402, 0x0cabc502, 0x0dab0202, 0x0dab4302, 0x0dab8402, 0x0dabc502, + 0x0eab0202, 0x0eab4302, 0x0eab8402, 0x0eabc502, 0x0fab0202, 0x0fab4302, 0x0fab8402, 0x0fabc502, + 0x10ab0202, 0x10ab4302, 0x10ab8402, 0x10abc502, 0x11ab0202, 0x11ab4302, 0x11ab8402, 0x11abc502, + 0x12ab0202, 0x12ab4302, 0x12ab8402, 0x12abc502, 0x13ab0202, 0x13ab4302, 0x13ab8402, 0x13abc502, + 0x14ab0202, 0x14ab4302, 0x14ab8402, 0x14abc502, 0x15ab0202, 0x15ab4302, 0x15ab8402, 0x15abc502, + 0x16ab0202, 0x16ab4302, 0x16ab8402, 0x16abc502, 0x17ab0202, 0x17ab4302, 0x17ab8402, 0x17abc502, + 0x18ab0202, 0x18ab4302, 0x18ab8402, 0x18abc502, 0x19ab0202, 0x19ab4302, 0x19ab8402, 0x19abc502, + 0x1aab0202, 0x1aab4302, 0x1aab8402, 0x1aabc502, 0x1bab0202, 0x1bab4302, 0x1bab8402, 0x1babc502, + 0x1cab0202, 0x1cab4302, 0x1cab8402, 0x1cabc502, 0x1dab0202, 0x1dab4302, 0x1dab8402, 0x1dabc502, + 0x1eab0202, 0x1eab4302, 0x1eab8402, 0x1eabc502, 0x1fab0202, 0x1fab4302, 0x1fab8402, 0x1fabc502, + 0x20ab0202, 0x20ab4302, 0x20ab8402, 0x20abc502, 0x21ab0202, 0x21ab4302, 0x21ab8402, 0x21abc502, + 0x22ab0202, 0x22ab4302, 0x22ab8402, 0x22abc502, 0x23ab0202, 0x23ab4302, 0x23ab8402, 0x23abc502, + 0x24ab0202, 0x24ab4302, 0x24ab8402, 0x24abc502, 0x25ab0202, 0x25ab4302, 0x25ab8402, 0x25abc502, + 0x26ab0202, 0x26ab4302, 0x26ab8402, 0x26abc502, 0x27ab0202, 0x27ab4302, 0x27ab8402, 0x27abc502, + 0x28ab0202, 0x28ab4302, 0x28ab8402, 0x28abc502, 0x29ab0202, 0x29ab4302, 0x29ab8402, 0x29abc502, + 0x2aab0202, 0x2aab4302, 0x2aab8402, 0x2aabc502, 0x2bab0202, 0x2bab4302, 0x2bab8402, 0x2babc502, + 0x2cab0202, 0x2cab4302, 0x2cab8402, 0x2cabc502, 0x2dab0202, 0x2dab4302, 0x2dab8402, 0x2dabc502, + 0x2eab0202, 0x2eab4302, 0x2eab8402, 0x2eabc502, 0x2fab0202, 0x2fab4302, 0x2fab8402, 0x2fabc502, + 0x30ab0202, 0x30ab4302, 0x30ab8402, 0x30abc502, 0x31ab0202, 0x31ab4302, 0x31ab8402, 0x31abc502, + 0x32ab0202, 0x32ab4302, 0x32ab8402, 0x32abc502, 0x33ab0202, 0x33ab4302, 0x33ab8402, 0x33abc502, + 0x34ab0202, 0x34ab4302, 0x34ab8402, 0x34abc502, 0x35ab0202, 0x35ab4302, 0x35ab8402, 0x35abc502, + 0x36ab0202, 0x36ab4302, 0x36ab8402, 0x36abc502, 0x37ab0202, 0x37ab4302, 0x37ab8402, 0x37abc502, + 0x38ab0202, 0x38ab4302, 0x38ab8402, 0x38abc502, 0x39ab0202, 0x39ab4302, 0x39ab8402, 0x39abc502, + 0x3aab0202, 0x3aab4302, 0x3aab8402, 0x3aabc502, 0x3bab0202, 0x3bab4302, 0x3bab8402, 0x3babc502, + 0x3cab0202, 0x3cab4302, 0x3cab8402, 0x3cabc502, 0x3dab0202, 0x3dab4302, 0x3dab8402, 0x3dabc502, + 0x3eab0202, 0x3eab4302, 0x3eab8402, 0x3eabc502, 0x3fab0202, 0x3fab4302, 0x3fab8402, 0x3fabc502, + 0x40ab0202, 0x40ab4302, 0x40ab8402, 0x40abc502, 0x41ab0202, 0x41ab4302, 0x41ab8402, 0x41abc502, + 0x42ab0202, 0x42ab4302, 0x42ab8402, 0x42abc502, 0x43ab0202, 0x43ab4302, 0x43ab8402, 0x43abc502, + 0x44ab0202, 0x44ab4302, 0x44ab8402, 0x44abc502, 0x45ab0202, 0x45ab4302, 0x45ab8402, 0x45abc502, + 0x46ab0202, 0x46ab4302, 0x46ab8402, 0x46abc502, 0x47ab0202, 0x47ab4302, 0x47ab8402, 0x47abc502, + 0x48ab0202, 0x48ab4302, 0x48ab8402, 0x48abc502, 0x49ab0202, 0x49ab4302, 0x49ab8402, 0x49abc502, + 0x4aab0202, 0x4aab4302, 0x4aab8402, 0x4aabc502, 0x4bab0202, 0x4bab4302, 0x4bab8402, 0x4babc502, + 0x4cab0202, 0x4cab4302, 0x4cab8402, 0x4cabc502, 0x4dab0202, 0x4dab4302, 0x4dab8402, 0x4dabc502, + 0x4eab0202, 0x4eab4302, 0x4eab8402, 0x4eabc502, 0x4fab0202, 0x4fab4302, 0x4fab8402, 0x4fabc502, + 0x50ab0202, 0x50ab4302, 0x50ab8402, 0x50abc502, 0x51ab0202, 0x51ab4302, 0x51ab8402, 0x51abc502, + 0x52ab0202, 0x52ab4302, 0x52ab8402, 0x52abc502, 0x53ab0202, 0x53ab4302, 0x53ab8402, 0x53abc502, + 0x54ab0202, 0x54ab4302, 0x54ab8402, 0x54abc502, 0x55ab0202, 0x55ab4302, 0x55ab8402, 0x55abc502, + 0x56ab0202, 0x56ab4302, 0x56ab8402, 0x56abc502, 0x57ab0202, 0x57ab4302, 0x57ab8402, 0x57abc502, + 0x58ab0202, 0x58ab4302, 0x58ab8402, 0x58abc502, 0x59ab0202, 0x59ab4302, 0x59ab8402, 0x59abc502, + 0x5aab0202, 0x5aab4302, 0x5aab8402, 0x5aabc502, 0x5bab0202, 0x5bab4302, 0x5bab8402, 0x5babc502, + 0x5cab0202, 0x5cab4302, 0x5cab8402, 0x5cabc502, 0x5dab0202, 0x5dab4302, 0x5dab8402, 0x5dabc502, + 0x5eab0202, 0x5eab4302, 0x5eab8402, 0x5eabc502, 0x5fab0202, 0x5fab4302, 0x5fab8402, 0x5fabc502, + 0x60ab0202, 0x60ab4302, 0x60ab8402, 0x60abc502, 0x61ab0202, 0x61ab4302, 0x61ab8402, 0x61abc502, + 0x62ab0202, 0x62ab4302, 0x62ab8402, 0x62abc502, 0x63ab0202, 0x63ab4302, 0x63ab8402, 0x63abc502, + 0x64ab0202, 0x64ab4302, 0x64ab8402, 0x64abc502, 0x65ab0202, 0x65ab4302, 0x65ab8402, 0x65abc502, + 0x66ab0202, 0x66ab4302, 0x66ab8402, 0x66abc502, 0x67ab0202, 0x67ab4302, 0x67ab8402, 0x67abc502, + 0x68ab0202, 0x68ab4302, 0x68ab8402, 0x68abc502, 0x69ab0202, 0x69ab4302, 0x69ab8402, 0x69abc502, + 0x6aab0202, 0x6aab4302, 0x6aab8402, 0x6aabc502, 0x6bab0202, 0x6bab4302, 0x6bab8402, 0x6babc502, + 0x6cab0202, 0x6cab4302, 0x6cab8402, 0x6cabc502, 0x6dab0202, 0x6dab4302, 0x6dab8402, 0x6dabc502, + 0x6eab0202, 0x6eab4302, 0x6eab8402, 0x6eabc502, 0x6fab0202, 0x6fab4302, 0x6fab8402, 0x6fabc502, + 0x70ab0202, 0x70ab4302, 0x70ab8402, 0x70abc502, 0x71ab0202, 0x71ab4302, 0x71ab8402, 0x71abc502, + 0x72ab0202, 0x72ab4302, 0x72ab8402, 0x72abc502, 0x73ab0202, 0x73ab4302, 0x73ab8402, 0x73abc502, + 0x74ab0202, 0x74ab4302, 0x74ab8402, 0x74abc502, 0x75ab0202, 0x75ab4302, 0x75ab8402, 0x75abc502, + 0x76ab0202, 0x76ab4302, 0x76ab8402, 0x76abc502, 0x77ab0202, 0x77ab4302, 0x77ab8402, 0x77abc502, + 0x78ab0202, 0x78ab4302, 0x78ab8402, 0x78abc502, 0x79ab0202, 0x79ab4302, 0x79ab8402, 0x79abc502, + 0x7aab0202, 0x7aab4302, 0x7aab8402, 0x7aabc502, 0x7bab0202, 0x7bab4302, 0x7bab8402, 0x7babc502, + 0x7cab0202, 0x7cab4302, 0x7cab8402, 0x7cabc502, 0x7dab0202, 0x7dab4302, 0x7dab8402, 0x7dabc502, + 0x7eab0202, 0x7eab4302, 0x7eab8402, 0x7eabc502, 0x7fab0202, 0x7fab4302, 0x7fab8402, 0x7fabc502, + 0x80ab0202, 0x80ab4302, 0x80ab8402, 0x80abc502, 0x81ab0202, 0x81ab4302, 0x81ab8402, 0x81abc502, + 0x82ab0202, 0x82ab4302, 0x82ab8402, 0x82abc502, 0x83ab0202, 0x83ab4302, 0x83ab8402, 0x83abc502, + 0x84ab0202, 0x84ab4302, 0x84ab8402, 0x84abc502, 0x85ab0202, 0x85ab4302, 0x85ab8402, 0x85abc502, + 0x86ab0202, 0x86ab4302, 0x86ab8402, 0x86abc502, 0x87ab0202, 0x87ab4302, 0x87ab8402, 0x87abc502, + 0x88ab0202, 0x88ab4302, 0x88ab8402, 0x88abc502, 0x89ab0202, 0x89ab4302, 0x89ab8402, 0x89abc502, + 0x8aab0202, 0x8aab4302, 0x8aab8402, 0x8aabc502, 0x8bab0202, 0x8bab4302, 0x8bab8402, 0x8babc502, + 0x8cab0202, 0x8cab4302, 0x8cab8402, 0x8cabc502, 0x8dab0202, 0x8dab4302, 0x8dab8402, 0x8dabc502, + 0x8eab0202, 0x8eab4302, 0x8eab8402, 0x8eabc502, 0x8fab0202, 0x8fab4302, 0x8fab8402, 0x8fabc502, + 0x90ab0202, 0x90ab4302, 0x90ab8402, 0x90abc502, 0x91ab0202, 0x91ab4302, 0x91ab8402, 0x91abc502, + 0x92ab0202, 0x92ab4302, 0x92ab8402, 0x92abc502, 0x93ab0202, 0x93ab4302, 0x93ab8402, 0x93abc502, + 0x94ab0202, 0x94ab4302, 0x94ab8402, 0x94abc502, 0x95ab0202, 0x95ab4302, 0x95ab8402, 0x95abc502, + 0x96ab0202, 0x96ab4302, 0x96ab8402, 0x96abc502, 0x97ab0202, 0x97ab4302, 0x97ab8402, 0x97abc502, + 0x98ab0202, 0x98ab4302, 0x98ab8402, 0x98abc502, 0x99ab0202, 0x99ab4302, 0x99ab8402, 0x99abc502, + 0x9aab0202, 0x9aab4302, 0x9aab8402, 0x9aabc502, 0x9bab0202, 0x9bab4302, 0x9bab8402, 0x9babc502, + 0x9cab0202, 0x9cab4302, 0x9cab8402, 0x9cabc502, 0x9dab0202, 0x9dab4302, 0x9dab8402, 0x9dabc502, + 0x9eab0202, 0x9eab4302, 0x9eab8402, 0x9eabc502, 0x9fab0202, 0x9fab4302, 0x9fab8402, 0x9fabc502, + 0xa0ab0202, 0xa0ab4302, 0xa0ab8402, 0xa0abc502, 0xa1ab0202, 0xa1ab4302, 0xa1ab8402, 0xa1abc502, + 0xa2ab0202, 0xa2ab4302, 0xa2ab8402, 0xa2abc502, 0xa3ab0202, 0xa3ab4302, 0xa3ab8402, 0xa3abc502, + 0xa4ab0202, 0xa4ab4302, 0xa4ab8402, 0xa4abc502, 0xa5ab0202, 0xa5ab4302, 0xa5ab8402, 0xa5abc502, + 0xa6ab0202, 0xa6ab4302, 0xa6ab8402, 0xa6abc502, 0xa7ab0202, 0xa7ab4302, 0xa7ab8402, 0xa7abc502, + 0xa8ab0202, 0xa8ab4302, 0xa8ab8402, 0xa8abc502, 0xa9ab0202, 0xa9ab4302, 0xa9ab8402, 0xa9abc502, + 0xaaab0202, 0xaaab4302, 0xaaab8402, 0xaaabc502, 0xabab0202, 0xabab4302, 0xabab8402, 0xababc502, + 0xacab0202, 0xacab4302, 0xacab8402, 0xacabc502, 0xadab0202, 0xadab4302, 0xadab8402, 0xadabc502, + 0xaeab0202, 0xaeab4302, 0xaeab8402, 0xaeabc502, 0xafab0202, 0xafab4302, 0xafab8402, 0xafabc502, + 0xb0ab0202, 0xb0ab4302, 0xb0ab8402, 0xb0abc502, 0xb1ab0202, 0xb1ab4302, 0xb1ab8402, 0xb1abc502, + 0xb2ab0202, 0xb2ab4302, 0xb2ab8402, 0xb2abc502, 0xb3ab0202, 0xb3ab4302, 0xb3ab8402, 0xb3abc502, + 0xb4ab0202, 0xb4ab4302, 0xb4ab8402, 0xb4abc502, 0xb5ab0202, 0xb5ab4302, 0xb5ab8402, 0xb5abc502, + 0xb6ab0202, 0xb6ab4302, 0xb6ab8402, 0xb6abc502, 0xb7ab0202, 0xb7ab4302, 0xb7ab8402, 0xb7abc502, + 0xb8ab0202, 0xb8ab4302, 0xb8ab8402, 0xb8abc502, 0xb9ab0202, 0xb9ab4302, 0xb9ab8402, 0xb9abc502, + 0xbaab0202, 0xbaab4302, 0xbaab8402, 0xbaabc502, 0xbbab0202, 0xbbab4302, 0xbbab8402, 0xbbabc502, + 0xbcab0202, 0xbcab4302, 0xbcab8402, 0xbcabc502, 0xbdab0202, 0xbdab4302, 0xbdab8402, 0xbdabc502, + 0xbeab0202, 0xbeab4302, 0xbeab8402, 0xbeabc502, 0xbfab0202, 0xbfab4302, 0xbfab8402, 0xbfabc502, + 0xc0ab0202, 0xc0ab4302, 0xc0ab8402, 0xc0abc502, 0xc1ab0202, 0xc1ab4302, 0xc1ab8402, 0xc1abc502, + 0xc2ab0202, 0xc2ab4302, 0xc2ab8402, 0xc2abc502, 0xc3ab0202, 0xc3ab4302, 0xc3ab8402, 0xc3abc502, + 0xc4ab0202, 0xc4ab4302, 0xc4ab8402, 0xc4abc502, 0xc5ab0202, 0xc5ab4302, 0xc5ab8402, 0xc5abc502, + 0xc6ab0202, 0xc6ab4302, 0xc6ab8402, 0xc6abc502, 0xc7ab0202, 0xc7ab4302, 0xc7ab8402, 0xc7abc502, + 0xc8ab0202, 0xc8ab4302, 0xc8ab8402, 0xc8abc502, 0xc9ab0202, 0xc9ab4302, 0xc9ab8402, 0xc9abc502, + 0xcaab0202, 0xcaab4302, 0xcaab8402, 0xcaabc502, 0xcbab0202, 0xcbab4302, 0xcbab8402, 0xcbabc502, + 0xccab0202, 0xccab4302, 0xccab8402, 0xccabc502, 0xcdab0202, 0xcdab4302, 0xcdab8402, 0xcdabc502, + 0xceab0202, 0xceab4302, 0xceab8402, 0xceabc502, 0xcfab0202, 0xcfab4302, 0xcfab8402, 0xcfabc502, + 0xd0ab0202, 0xd0ab4302, 0xd0ab8402, 0xd0abc502, 0xd1ab0202, 0xd1ab4302, 0xd1ab8402, 0xd1abc502, + 0xd2ab0202, 0xd2ab4302, 0xd2ab8402, 0xd2abc502, 0xd3ab0202, 0xd3ab4302, 0xd3ab8402, 0xd3abc502, + 0xd4ab0202, 0xd4ab4302, 0xd4ab8402, 0xd4abc502, 0xd5ab0202, 0xd5ab4302, 0xd5ab8402, 0xd5abc502, + 0xd6ab0202, 0xd6ab4302, 0xd6ab8402, 0xd6abc502, 0xd7ab0202, 0xd7ab4302, 0xd7ab8402, 0xd7abc502, + 0xd8ab0202, 0xd8ab4302, 0xd8ab8402, 0xd8abc502, 0xd9ab0202, 0xd9ab4302, 0xd9ab8402, 0xd9abc502, + 0xdaab0202, 0xdaab4302, 0xdaab8402, 0xdaabc502, 0xdbab0202, 0xdbab4302, 0xdbab8402, 0xdbabc502, + 0xdcab0202, 0xdcab4302, 0xdcab8402, 0xdcabc502, 0xddab0202, 0xddab4302, 0xddab8402, 0xddabc502, + 0xdeab0202, 0xdeab4302, 0xdeab8402, 0xdeabc502, 0xdfab0202, 0xdfab4302, 0xdfab8402, 0xdfabc502, + 0xe0ab0202, 0xe0ab4302, 0xe0ab8402, 0xe0abc502, 0xe1ab0202, 0xe1ab4302, 0xe1ab8402, 0xe1abc502, + 0xe2ab0202, 0xe2ab4302, 0xe2ab8402, 0xe2abc502, 0xe3ab0202, 0xe3ab4302, 0xe3ab8402, 0xe3abc502, + 0xe4ab0202, 0xe4ab4302, 0xe4ab8402, 0xe4abc502, 0xe5ab0202, 0xe5ab4302, 0xe5ab8402, 0xe5abc502, + 0xe6ab0202, 0xe6ab4302, 0xe6ab8402, 0xe6abc502, 0xe7ab0202, 0xe7ab4302, 0xe7ab8402, 0xe7abc502, + 0xe8ab0202, 0xe8ab4302, 0xe8ab8402, 0xe8abc502, 0xe9ab0202, 0xe9ab4302, 0xe9ab8402, 0xe9abc502, + 0xeaab0202, 0xeaab4302, 0xeaab8402, 0xeaabc502, 0xebab0202, 0xebab4302, 0xebab8402, 0xebabc502, + 0xecab0202, 0xecab4302, 0xecab8402, 0xecabc502, 0xedab0202, 0xedab4302, 0xedab8402, 0xedabc502, + 0xeeab0202, 0xeeab4302, 0xeeab8402, 0xeeabc502, 0xefab0202, 0xefab4302, 0xefab8402, 0xefabc502, + 0xf0ab0202, 0xf0ab4302, 0xf0ab8402, 0xf0abc502, 0xf1ab0202, 0xf1ab4302, 0xf1ab8402, 0xf1abc502, + 0xf2ab0202, 0xf2ab4302, 0xf2ab8402, 0xf2abc502, 0xf3ab0202, 0xf3ab4302, 0xf3ab8402, 0xf3abc502, + 0xf4ab0202, 0xf4ab4302, 0xf4ab8402, 0xf4abc502, 0xf5ab0202, 0xf5ab4302, 0xf5ab8402, 0xf5abc502, + 0xf6ab0202, 0xf6ab4302, 0xf6ab8402, 0xf6abc502, 0xf7ab0202, 0xf7ab4302, 0xf7ab8402, 0xf7abc502, + 0xf8ab0202, 0xf8ab4302, 0xf8ab8402, 0xf8abc502, 0xf9ab0202, 0xf9ab4302, 0xf9ab8402, 0xf9abc502, + 0xfaab0202, 0xfaab4302, 0xfaab8402, 0xfaabc502, 0xfbab0202, 0xfbab4302, 0xfbab8402, 0xfbabc502, + 0xfcab0202, 0xfcab4302, 0xfcab8402, 0xfcabc502, 0xfdab0202, 0xfdab4302, 0xfdab8402, 0xfdabc502, + 0xfeab0202, 0xfeab4302, 0xfeab8402, 0xfeabc502, 0xffab0202, 0xffab4302, 0xffab8402, 0xffabc502, + 0x02ac0202, 0x02ac4302, 0x02ac8402, 0x02acc502, 0x03ac0202, 0x03ac4302, 0x03ac8402, 0x03acc502, + 0x04ac0202, 0x04ac4302, 0x04ac8402, 0x04acc502, 0x05ac0202, 0x05ac4302, 0x05ac8402, 0x05acc502, + 0x06ac0202, 0x06ac4302, 0x06ac8402, 0x06acc502, 0x07ac0202, 0x07ac4302, 0x07ac8402, 0x07acc502, + 0x08ac0202, 0x08ac4302, 0x08ac8402, 0x08acc502, 0x09ac0202, 0x09ac4302, 0x09ac8402, 0x09acc502, + 0x0aac0202, 0x0aac4302, 0x0aac8402, 0x0aacc502, 0x0bac0202, 0x0bac4302, 0x0bac8402, 0x0bacc502, + 0x0cac0202, 0x0cac4302, 0x0cac8402, 0x0cacc502, 0x0dac0202, 0x0dac4302, 0x0dac8402, 0x0dacc502, + 0x0eac0202, 0x0eac4302, 0x0eac8402, 0x0eacc502, 0x0fac0202, 0x0fac4302, 0x0fac8402, 0x0facc502, + 0x10ac0202, 0x10ac4302, 0x10ac8402, 0x10acc502, 0x11ac0202, 0x11ac4302, 0x11ac8402, 0x11acc502, + 0x12ac0202, 0x12ac4302, 0x12ac8402, 0x12acc502, 0x13ac0202, 0x13ac4302, 0x13ac8402, 0x13acc502, + 0x14ac0202, 0x14ac4302, 0x14ac8402, 0x14acc502, 0x15ac0202, 0x15ac4302, 0x15ac8402, 0x15acc502, + 0x16ac0202, 0x16ac4302, 0x16ac8402, 0x16acc502, 0x17ac0202, 0x17ac4302, 0x17ac8402, 0x17acc502, + 0x18ac0202, 0x18ac4302, 0x18ac8402, 0x18acc502, 0x19ac0202, 0x19ac4302, 0x19ac8402, 0x19acc502, + 0x1aac0202, 0x1aac4302, 0x1aac8402, 0x1aacc502, 0x1bac0202, 0x1bac4302, 0x1bac8402, 0x1bacc502, + 0x1cac0202, 0x1cac4302, 0x1cac8402, 0x1cacc502, 0x1dac0202, 0x1dac4302, 0x1dac8402, 0x1dacc502, + 0x1eac0202, 0x1eac4302, 0x1eac8402, 0x1eacc502, 0x1fac0202, 0x1fac4302, 0x1fac8402, 0x1facc502, + 0x20ac0202, 0x20ac4302, 0x20ac8402, 0x20acc502, 0x21ac0202, 0x21ac4302, 0x21ac8402, 0x21acc502, + 0x22ac0202, 0x22ac4302, 0x22ac8402, 0x22acc502, 0x23ac0202, 0x23ac4302, 0x23ac8402, 0x23acc502, + 0x24ac0202, 0x24ac4302, 0x24ac8402, 0x24acc502, 0x25ac0202, 0x25ac4302, 0x25ac8402, 0x25acc502, + 0x26ac0202, 0x26ac4302, 0x26ac8402, 0x26acc502, 0x27ac0202, 0x27ac4302, 0x27ac8402, 0x27acc502, + 0x28ac0202, 0x28ac4302, 0x28ac8402, 0x28acc502, 0x29ac0202, 0x29ac4302, 0x29ac8402, 0x29acc502, + 0x2aac0202, 0x2aac4302, 0x2aac8402, 0x2aacc502, 0x2bac0202, 0x2bac4302, 0x2bac8402, 0x2bacc502, + 0x2cac0202, 0x2cac4302, 0x2cac8402, 0x2cacc502, 0x2dac0202, 0x2dac4302, 0x2dac8402, 0x2dacc502, + 0x2eac0202, 0x2eac4302, 0x2eac8402, 0x2eacc502, 0x2fac0202, 0x2fac4302, 0x2fac8402, 0x2facc502, + 0x30ac0202, 0x30ac4302, 0x30ac8402, 0x30acc502, 0x31ac0202, 0x31ac4302, 0x31ac8402, 0x31acc502, + 0x32ac0202, 0x32ac4302, 0x32ac8402, 0x32acc502, 0x33ac0202, 0x33ac4302, 0x33ac8402, 0x33acc502, + 0x34ac0202, 0x34ac4302, 0x34ac8402, 0x34acc502, 0x35ac0202, 0x35ac4302, 0x35ac8402, 0x35acc502, + 0x36ac0202, 0x36ac4302, 0x36ac8402, 0x36acc502, 0x37ac0202, 0x37ac4302, 0x37ac8402, 0x37acc502, + 0x38ac0202, 0x38ac4302, 0x38ac8402, 0x38acc502, 0x39ac0202, 0x39ac4302, 0x39ac8402, 0x39acc502, + 0x3aac0202, 0x3aac4302, 0x3aac8402, 0x3aacc502, 0x3bac0202, 0x3bac4302, 0x3bac8402, 0x3bacc502, + 0x3cac0202, 0x3cac4302, 0x3cac8402, 0x3cacc502, 0x3dac0202, 0x3dac4302, 0x3dac8402, 0x3dacc502, + 0x3eac0202, 0x3eac4302, 0x3eac8402, 0x3eacc502, 0x3fac0202, 0x3fac4302, 0x3fac8402, 0x3facc502, + 0x40ac0202, 0x40ac4302, 0x40ac8402, 0x40acc502, 0x41ac0202, 0x41ac4302, 0x41ac8402, 0x41acc502, + 0x42ac0202, 0x42ac4302, 0x42ac8402, 0x42acc502, 0x43ac0202, 0x43ac4302, 0x43ac8402, 0x43acc502, + 0x44ac0202, 0x44ac4302, 0x44ac8402, 0x44acc502, 0x45ac0202, 0x45ac4302, 0x45ac8402, 0x45acc502, + 0x46ac0202, 0x46ac4302, 0x46ac8402, 0x46acc502, 0x47ac0202, 0x47ac4302, 0x47ac8402, 0x47acc502, + 0x48ac0202, 0x48ac4302, 0x48ac8402, 0x48acc502, 0x49ac0202, 0x49ac4302, 0x49ac8402, 0x49acc502, + 0x4aac0202, 0x4aac4302, 0x4aac8402, 0x4aacc502, 0x4bac0202, 0x4bac4302, 0x4bac8402, 0x4bacc502, + 0x4cac0202, 0x4cac4302, 0x4cac8402, 0x4cacc502, 0x4dac0202, 0x4dac4302, 0x4dac8402, 0x4dacc502, + 0x4eac0202, 0x4eac4302, 0x4eac8402, 0x4eacc502, 0x4fac0202, 0x4fac4302, 0x4fac8402, 0x4facc502, + 0x50ac0202, 0x50ac4302, 0x50ac8402, 0x50acc502, 0x51ac0202, 0x51ac4302, 0x51ac8402, 0x51acc502, + 0x52ac0202, 0x52ac4302, 0x52ac8402, 0x52acc502, 0x53ac0202, 0x53ac4302, 0x53ac8402, 0x53acc502, + 0x54ac0202, 0x54ac4302, 0x54ac8402, 0x54acc502, 0x55ac0202, 0x55ac4302, 0x55ac8402, 0x55acc502, + 0x56ac0202, 0x56ac4302, 0x56ac8402, 0x56acc502, 0x57ac0202, 0x57ac4302, 0x57ac8402, 0x57acc502, + 0x58ac0202, 0x58ac4302, 0x58ac8402, 0x58acc502, 0x59ac0202, 0x59ac4302, 0x59ac8402, 0x59acc502, + 0x5aac0202, 0x5aac4302, 0x5aac8402, 0x5aacc502, 0x5bac0202, 0x5bac4302, 0x5bac8402, 0x5bacc502, + 0x5cac0202, 0x5cac4302, 0x5cac8402, 0x5cacc502, 0x5dac0202, 0x5dac4302, 0x5dac8402, 0x5dacc502, + 0x5eac0202, 0x5eac4302, 0x5eac8402, 0x5eacc502, 0x5fac0202, 0x5fac4302, 0x5fac8402, 0x5facc502, + 0x60ac0202, 0x60ac4302, 0x60ac8402, 0x60acc502, 0x61ac0202, 0x61ac4302, 0x61ac8402, 0x61acc502, + 0x62ac0202, 0x62ac4302, 0x62ac8402, 0x62acc502, 0x63ac0202, 0x63ac4302, 0x63ac8402, 0x63acc502, + 0x64ac0202, 0x64ac4302, 0x64ac8402, 0x64acc502, 0x65ac0202, 0x65ac4302, 0x65ac8402, 0x65acc502, + 0x66ac0202, 0x66ac4302, 0x66ac8402, 0x66acc502, 0x67ac0202, 0x67ac4302, 0x67ac8402, 0x67acc502, + 0x68ac0202, 0x68ac4302, 0x68ac8402, 0x68acc502, 0x69ac0202, 0x69ac4302, 0x69ac8402, 0x69acc502, + 0x6aac0202, 0x6aac4302, 0x6aac8402, 0x6aacc502, 0x6bac0202, 0x6bac4302, 0x6bac8402, 0x6bacc502, + 0x6cac0202, 0x6cac4302, 0x6cac8402, 0x6cacc502, 0x6dac0202, 0x6dac4302, 0x6dac8402, 0x6dacc502, + 0x6eac0202, 0x6eac4302, 0x6eac8402, 0x6eacc502, 0x6fac0202, 0x6fac4302, 0x6fac8402, 0x6facc502, + 0x70ac0202, 0x70ac4302, 0x70ac8402, 0x70acc502, 0x71ac0202, 0x71ac4302, 0x71ac8402, 0x71acc502, + 0x72ac0202, 0x72ac4302, 0x72ac8402, 0x72acc502, 0x73ac0202, 0x73ac4302, 0x73ac8402, 0x73acc502, + 0x74ac0202, 0x74ac4302, 0x74ac8402, 0x74acc502, 0x75ac0202, 0x75ac4302, 0x75ac8402, 0x75acc502, + 0x76ac0202, 0x76ac4302, 0x76ac8402, 0x76acc502, 0x77ac0202, 0x77ac4302, 0x77ac8402, 0x77acc502, + 0x78ac0202, 0x78ac4302, 0x78ac8402, 0x78acc502, 0x79ac0202, 0x79ac4302, 0x79ac8402, 0x79acc502, + 0x7aac0202, 0x7aac4302, 0x7aac8402, 0x7aacc502, 0x7bac0202, 0x7bac4302, 0x7bac8402, 0x7bacc502, + 0x7cac0202, 0x7cac4302, 0x7cac8402, 0x7cacc502, 0x7dac0202, 0x7dac4302, 0x7dac8402, 0x7dacc502, + 0x7eac0202, 0x7eac4302, 0x7eac8402, 0x7eacc502, 0x7fac0202, 0x7fac4302, 0x7fac8402, 0x7facc502, + 0x80ac0202, 0x80ac4302, 0x80ac8402, 0x80acc502, 0x81ac0202, 0x81ac4302, 0x81ac8402, 0x81acc502, + 0x82ac0202, 0x82ac4302, 0x82ac8402, 0x82acc502, 0x83ac0202, 0x83ac4302, 0x83ac8402, 0x83acc502, + 0x84ac0202, 0x84ac4302, 0x84ac8402, 0x84acc502, 0x85ac0202, 0x85ac4302, 0x85ac8402, 0x85acc502, + 0x86ac0202, 0x86ac4302, 0x86ac8402, 0x86acc502, 0x87ac0202, 0x87ac4302, 0x87ac8402, 0x87acc502, + 0x88ac0202, 0x88ac4302, 0x88ac8402, 0x88acc502, 0x89ac0202, 0x89ac4302, 0x89ac8402, 0x89acc502, + 0x8aac0202, 0x8aac4302, 0x8aac8402, 0x8aacc502, 0x8bac0202, 0x8bac4302, 0x8bac8402, 0x8bacc502, + 0x8cac0202, 0x8cac4302, 0x8cac8402, 0x8cacc502, 0x8dac0202, 0x8dac4302, 0x8dac8402, 0x8dacc502, + 0x8eac0202, 0x8eac4302, 0x8eac8402, 0x8eacc502, 0x8fac0202, 0x8fac4302, 0x8fac8402, 0x8facc502, + 0x90ac0202, 0x90ac4302, 0x90ac8402, 0x90acc502, 0x91ac0202, 0x91ac4302, 0x91ac8402, 0x91acc502, + 0x92ac0202, 0x92ac4302, 0x92ac8402, 0x92acc502, 0x93ac0202, 0x93ac4302, 0x93ac8402, 0x93acc502, + 0x94ac0202, 0x94ac4302, 0x94ac8402, 0x94acc502, 0x95ac0202, 0x95ac4302, 0x95ac8402, 0x95acc502, + 0x96ac0202, 0x96ac4302, 0x96ac8402, 0x96acc502, 0x97ac0202, 0x97ac4302, 0x97ac8402, 0x97acc502, + 0x98ac0202, 0x98ac4302, 0x98ac8402, 0x98acc502, 0x99ac0202, 0x99ac4302, 0x99ac8402, 0x99acc502, + 0x9aac0202, 0x9aac4302, 0x9aac8402, 0x9aacc502, 0x9bac0202, 0x9bac4302, 0x9bac8402, 0x9bacc502, + 0x9cac0202, 0x9cac4302, 0x9cac8402, 0x9cacc502, 0x9dac0202, 0x9dac4302, 0x9dac8402, 0x9dacc502, + 0x9eac0202, 0x9eac4302, 0x9eac8402, 0x9eacc502, 0x9fac0202, 0x9fac4302, 0x9fac8402, 0x9facc502, + 0xa0ac0202, 0xa0ac4302, 0xa0ac8402, 0xa0acc502, 0xa1ac0202, 0xa1ac4302, 0xa1ac8402, 0xa1acc502, + 0xa2ac0202, 0xa2ac4302, 0xa2ac8402, 0xa2acc502, 0xa3ac0202, 0xa3ac4302, 0xa3ac8402, 0xa3acc502, + 0xa4ac0202, 0xa4ac4302, 0xa4ac8402, 0xa4acc502, 0xa5ac0202, 0xa5ac4302, 0xa5ac8402, 0xa5acc502, + 0xa6ac0202, 0xa6ac4302, 0xa6ac8402, 0xa6acc502, 0xa7ac0202, 0xa7ac4302, 0xa7ac8402, 0xa7acc502, + 0xa8ac0202, 0xa8ac4302, 0xa8ac8402, 0xa8acc502, 0xa9ac0202, 0xa9ac4302, 0xa9ac8402, 0xa9acc502, + 0xaaac0202, 0xaaac4302, 0xaaac8402, 0xaaacc502, 0xabac0202, 0xabac4302, 0xabac8402, 0xabacc502, + 0xacac0202, 0xacac4302, 0xacac8402, 0xacacc502, 0xadac0202, 0xadac4302, 0xadac8402, 0xadacc502, + 0xaeac0202, 0xaeac4302, 0xaeac8402, 0xaeacc502, 0xafac0202, 0xafac4302, 0xafac8402, 0xafacc502, + 0xb0ac0202, 0xb0ac4302, 0xb0ac8402, 0xb0acc502, 0xb1ac0202, 0xb1ac4302, 0xb1ac8402, 0xb1acc502, + 0xb2ac0202, 0xb2ac4302, 0xb2ac8402, 0xb2acc502, 0xb3ac0202, 0xb3ac4302, 0xb3ac8402, 0xb3acc502, + 0xb4ac0202, 0xb4ac4302, 0xb4ac8402, 0xb4acc502, 0xb5ac0202, 0xb5ac4302, 0xb5ac8402, 0xb5acc502, + 0xb6ac0202, 0xb6ac4302, 0xb6ac8402, 0xb6acc502, 0xb7ac0202, 0xb7ac4302, 0xb7ac8402, 0xb7acc502, + 0xb8ac0202, 0xb8ac4302, 0xb8ac8402, 0xb8acc502, 0xb9ac0202, 0xb9ac4302, 0xb9ac8402, 0xb9acc502, + 0xbaac0202, 0xbaac4302, 0xbaac8402, 0xbaacc502, 0xbbac0202, 0xbbac4302, 0xbbac8402, 0xbbacc502, + 0xbcac0202, 0xbcac4302, 0xbcac8402, 0xbcacc502, 0xbdac0202, 0xbdac4302, 0xbdac8402, 0xbdacc502, + 0xbeac0202, 0xbeac4302, 0xbeac8402, 0xbeacc502, 0xbfac0202, 0xbfac4302, 0xbfac8402, 0xbfacc502, + 0xc0ac0202, 0xc0ac4302, 0xc0ac8402, 0xc0acc502, 0xc1ac0202, 0xc1ac4302, 0xc1ac8402, 0xc1acc502, + 0xc2ac0202, 0xc2ac4302, 0xc2ac8402, 0xc2acc502, 0xc3ac0202, 0xc3ac4302, 0xc3ac8402, 0xc3acc502, + 0xc4ac0202, 0xc4ac4302, 0xc4ac8402, 0xc4acc502, 0xc5ac0202, 0xc5ac4302, 0xc5ac8402, 0xc5acc502, + 0xc6ac0202, 0xc6ac4302, 0xc6ac8402, 0xc6acc502, 0xc7ac0202, 0xc7ac4302, 0xc7ac8402, 0xc7acc502, + 0xc8ac0202, 0xc8ac4302, 0xc8ac8402, 0xc8acc502, 0xc9ac0202, 0xc9ac4302, 0xc9ac8402, 0xc9acc502, + 0xcaac0202, 0xcaac4302, 0xcaac8402, 0xcaacc502, 0xcbac0202, 0xcbac4302, 0xcbac8402, 0xcbacc502, + 0xccac0202, 0xccac4302, 0xccac8402, 0xccacc502, 0xcdac0202, 0xcdac4302, 0xcdac8402, 0xcdacc502, + 0xceac0202, 0xceac4302, 0xceac8402, 0xceacc502, 0xcfac0202, 0xcfac4302, 0xcfac8402, 0xcfacc502, + 0xd0ac0202, 0xd0ac4302, 0xd0ac8402, 0xd0acc502, 0xd1ac0202, 0xd1ac4302, 0xd1ac8402, 0xd1acc502, + 0xd2ac0202, 0xd2ac4302, 0xd2ac8402, 0xd2acc502, 0xd3ac0202, 0xd3ac4302, 0xd3ac8402, 0xd3acc502, + 0xd4ac0202, 0xd4ac4302, 0xd4ac8402, 0xd4acc502, 0xd5ac0202, 0xd5ac4302, 0xd5ac8402, 0xd5acc502, + 0xd6ac0202, 0xd6ac4302, 0xd6ac8402, 0xd6acc502, 0xd7ac0202, 0xd7ac4302, 0xd7ac8402, 0xd7acc502, + 0xd8ac0202, 0xd8ac4302, 0xd8ac8402, 0xd8acc502, 0xd9ac0202, 0xd9ac4302, 0xd9ac8402, 0xd9acc502, + 0xdaac0202, 0xdaac4302, 0xdaac8402, 0xdaacc502, 0xdbac0202, 0xdbac4302, 0xdbac8402, 0xdbacc502, + 0xdcac0202, 0xdcac4302, 0xdcac8402, 0xdcacc502, 0xddac0202, 0xddac4302, 0xddac8402, 0xddacc502, + 0xdeac0202, 0xdeac4302, 0xdeac8402, 0xdeacc502, 0xdfac0202, 0xdfac4302, 0xdfac8402, 0xdfacc502, + 0xe0ac0202, 0xe0ac4302, 0xe0ac8402, 0xe0acc502, 0xe1ac0202, 0xe1ac4302, 0xe1ac8402, 0xe1acc502, + 0xe2ac0202, 0xe2ac4302, 0xe2ac8402, 0xe2acc502, 0xe3ac0202, 0xe3ac4302, 0xe3ac8402, 0xe3acc502, + 0xe4ac0202, 0xe4ac4302, 0xe4ac8402, 0xe4acc502, 0xe5ac0202, 0xe5ac4302, 0xe5ac8402, 0xe5acc502, + 0xe6ac0202, 0xe6ac4302, 0xe6ac8402, 0xe6acc502, 0xe7ac0202, 0xe7ac4302, 0xe7ac8402, 0xe7acc502, + 0xe8ac0202, 0xe8ac4302, 0xe8ac8402, 0xe8acc502, 0xe9ac0202, 0xe9ac4302, 0xe9ac8402, 0xe9acc502, + 0xeaac0202, 0xeaac4302, 0xeaac8402, 0xeaacc502, 0xebac0202, 0xebac4302, 0xebac8402, 0xebacc502, + 0xecac0202, 0xecac4302, 0xecac8402, 0xecacc502, 0xedac0202, 0xedac4302, 0xedac8402, 0xedacc502, + 0xeeac0202, 0xeeac4302, 0xeeac8402, 0xeeacc502, 0xefac0202, 0xefac4302, 0xefac8402, 0xefacc502, + 0xf0ac0202, 0xf0ac4302, 0xf0ac8402, 0xf0acc502, 0xf1ac0202, 0xf1ac4302, 0xf1ac8402, 0xf1acc502, + 0xf2ac0202, 0xf2ac4302, 0xf2ac8402, 0xf2acc502, 0xf3ac0202, 0xf3ac4302, 0xf3ac8402, 0xf3acc502, + 0xf4ac0202, 0xf4ac4302, 0xf4ac8402, 0xf4acc502, 0xf5ac0202, 0xf5ac4302, 0xf5ac8402, 0xf5acc502, + 0xf6ac0202, 0xf6ac4302, 0xf6ac8402, 0xf6acc502, 0xf7ac0202, 0xf7ac4302, 0xf7ac8402, 0xf7acc502, + 0xf8ac0202, 0xf8ac4302, 0xf8ac8402, 0xf8acc502, 0xf9ac0202, 0xf9ac4302, 0xf9ac8402, 0xf9acc502, + 0xfaac0202, 0xfaac4302, 0xfaac8402, 0xfaacc502, 0xfbac0202, 0xfbac4302, 0xfbac8402, 0xfbacc502, + 0xfcac0202, 0xfcac4302, 0xfcac8402, 0xfcacc502, 0xfdac0202, 0xfdac4302, 0xfdac8402, 0xfdacc502, + 0xfeac0202, 0xfeac4302, 0xfeac8402, 0xfeacc502, 0xffac0202, 0xffac4302, 0xffac8402, 0xffacc502, + 0x02ad0202, 0x02ad4302, 0x02ad8402, 0x02adc502, 0x03ad0202, 0x03ad4302, 0x03ad8402, 0x03adc502, + 0x04ad0202, 0x04ad4302, 0x04ad8402, 0x04adc502, 0x05ad0202, 0x05ad4302, 0x05ad8402, 0x05adc502, + 0x06ad0202, 0x06ad4302, 0x06ad8402, 0x06adc502, 0x07ad0202, 0x07ad4302, 0x07ad8402, 0x07adc502, + 0x08ad0202, 0x08ad4302, 0x08ad8402, 0x08adc502, 0x09ad0202, 0x09ad4302, 0x09ad8402, 0x09adc502, + 0x0aad0202, 0x0aad4302, 0x0aad8402, 0x0aadc502, 0x0bad0202, 0x0bad4302, 0x0bad8402, 0x0badc502, + 0x0cad0202, 0x0cad4302, 0x0cad8402, 0x0cadc502, 0x0dad0202, 0x0dad4302, 0x0dad8402, 0x0dadc502, + 0x0ead0202, 0x0ead4302, 0x0ead8402, 0x0eadc502, 0x0fad0202, 0x0fad4302, 0x0fad8402, 0x0fadc502, + 0x10ad0202, 0x10ad4302, 0x10ad8402, 0x10adc502, 0x11ad0202, 0x11ad4302, 0x11ad8402, 0x11adc502, + 0x12ad0202, 0x12ad4302, 0x12ad8402, 0x12adc502, 0x13ad0202, 0x13ad4302, 0x13ad8402, 0x13adc502, + 0x14ad0202, 0x14ad4302, 0x14ad8402, 0x14adc502, 0x15ad0202, 0x15ad4302, 0x15ad8402, 0x15adc502, + 0x16ad0202, 0x16ad4302, 0x16ad8402, 0x16adc502, 0x17ad0202, 0x17ad4302, 0x17ad8402, 0x17adc502, + 0x18ad0202, 0x18ad4302, 0x18ad8402, 0x18adc502, 0x19ad0202, 0x19ad4302, 0x19ad8402, 0x19adc502, + 0x1aad0202, 0x1aad4302, 0x1aad8402, 0x1aadc502, 0x1bad0202, 0x1bad4302, 0x1bad8402, 0x1badc502, + 0x1cad0202, 0x1cad4302, 0x1cad8402, 0x1cadc502, 0x1dad0202, 0x1dad4302, 0x1dad8402, 0x1dadc502, + 0x1ead0202, 0x1ead4302, 0x1ead8402, 0x1eadc502, 0x1fad0202, 0x1fad4302, 0x1fad8402, 0x1fadc502, + 0x20ad0202, 0x20ad4302, 0x20ad8402, 0x20adc502, 0x21ad0202, 0x21ad4302, 0x21ad8402, 0x21adc502, + 0x22ad0202, 0x22ad4302, 0x22ad8402, 0x22adc502, 0x23ad0202, 0x23ad4302, 0x23ad8402, 0x23adc502, + 0x24ad0202, 0x24ad4302, 0x24ad8402, 0x24adc502, 0x25ad0202, 0x25ad4302, 0x25ad8402, 0x25adc502, + 0x26ad0202, 0x26ad4302, 0x26ad8402, 0x26adc502, 0x27ad0202, 0x27ad4302, 0x27ad8402, 0x27adc502, + 0x28ad0202, 0x28ad4302, 0x28ad8402, 0x28adc502, 0x29ad0202, 0x29ad4302, 0x29ad8402, 0x29adc502, + 0x2aad0202, 0x2aad4302, 0x2aad8402, 0x2aadc502, 0x2bad0202, 0x2bad4302, 0x2bad8402, 0x2badc502, + 0x2cad0202, 0x2cad4302, 0x2cad8402, 0x2cadc502, 0x2dad0202, 0x2dad4302, 0x2dad8402, 0x2dadc502, + 0x2ead0202, 0x2ead4302, 0x2ead8402, 0x2eadc502, 0x2fad0202, 0x2fad4302, 0x2fad8402, 0x2fadc502, + 0x30ad0202, 0x30ad4302, 0x30ad8402, 0x30adc502, 0x31ad0202, 0x31ad4302, 0x31ad8402, 0x31adc502, + 0x32ad0202, 0x32ad4302, 0x32ad8402, 0x32adc502, 0x33ad0202, 0x33ad4302, 0x33ad8402, 0x33adc502, + 0x34ad0202, 0x34ad4302, 0x34ad8402, 0x34adc502, 0x35ad0202, 0x35ad4302, 0x35ad8402, 0x35adc502, + 0x36ad0202, 0x36ad4302, 0x36ad8402, 0x36adc502, 0x37ad0202, 0x37ad4302, 0x37ad8402, 0x37adc502, + 0x38ad0202, 0x38ad4302, 0x38ad8402, 0x38adc502, 0x39ad0202, 0x39ad4302, 0x39ad8402, 0x39adc502, + 0x3aad0202, 0x3aad4302, 0x3aad8402, 0x3aadc502, 0x3bad0202, 0x3bad4302, 0x3bad8402, 0x3badc502, + 0x3cad0202, 0x3cad4302, 0x3cad8402, 0x3cadc502, 0x3dad0202, 0x3dad4302, 0x3dad8402, 0x3dadc502, + 0x3ead0202, 0x3ead4302, 0x3ead8402, 0x3eadc502, 0x3fad0202, 0x3fad4302, 0x3fad8402, 0x3fadc502, + 0x40ad0202, 0x40ad4302, 0x40ad8402, 0x40adc502, 0x41ad0202, 0x41ad4302, 0x41ad8402, 0x41adc502, + 0x42ad0202, 0x42ad4302, 0x42ad8402, 0x42adc502, 0x43ad0202, 0x43ad4302, 0x43ad8402, 0x43adc502, + 0x44ad0202, 0x44ad4302, 0x44ad8402, 0x44adc502, 0x45ad0202, 0x45ad4302, 0x45ad8402, 0x45adc502, + 0x46ad0202, 0x46ad4302, 0x46ad8402, 0x46adc502, 0x47ad0202, 0x47ad4302, 0x47ad8402, 0x47adc502, + 0x48ad0202, 0x48ad4302, 0x48ad8402, 0x48adc502, 0x49ad0202, 0x49ad4302, 0x49ad8402, 0x49adc502, + 0x4aad0202, 0x4aad4302, 0x4aad8402, 0x4aadc502, 0x4bad0202, 0x4bad4302, 0x4bad8402, 0x4badc502, + 0x4cad0202, 0x4cad4302, 0x4cad8402, 0x4cadc502, 0x4dad0202, 0x4dad4302, 0x4dad8402, 0x4dadc502, + 0x4ead0202, 0x4ead4302, 0x4ead8402, 0x4eadc502, 0x4fad0202, 0x4fad4302, 0x4fad8402, 0x4fadc502, + 0x50ad0202, 0x50ad4302, 0x50ad8402, 0x50adc502, 0x51ad0202, 0x51ad4302, 0x51ad8402, 0x51adc502, + 0x52ad0202, 0x52ad4302, 0x52ad8402, 0x52adc502, 0x53ad0202, 0x53ad4302, 0x53ad8402, 0x53adc502, + 0x54ad0202, 0x54ad4302, 0x54ad8402, 0x54adc502, 0x55ad0202, 0x55ad4302, 0x55ad8402, 0x55adc502, + 0x56ad0202, 0x56ad4302, 0x56ad8402, 0x56adc502, 0x57ad0202, 0x57ad4302, 0x57ad8402, 0x57adc502, + 0x58ad0202, 0x58ad4302, 0x58ad8402, 0x58adc502, 0x59ad0202, 0x59ad4302, 0x59ad8402, 0x59adc502, + 0x5aad0202, 0x5aad4302, 0x5aad8402, 0x5aadc502, 0x5bad0202, 0x5bad4302, 0x5bad8402, 0x5badc502, + 0x5cad0202, 0x5cad4302, 0x5cad8402, 0x5cadc502, 0x5dad0202, 0x5dad4302, 0x5dad8402, 0x5dadc502, + 0x5ead0202, 0x5ead4302, 0x5ead8402, 0x5eadc502, 0x5fad0202, 0x5fad4302, 0x5fad8402, 0x5fadc502, + 0x60ad0202, 0x60ad4302, 0x60ad8402, 0x60adc502, 0x61ad0202, 0x61ad4302, 0x61ad8402, 0x61adc502, + 0x62ad0202, 0x62ad4302, 0x62ad8402, 0x62adc502, 0x63ad0202, 0x63ad4302, 0x63ad8402, 0x63adc502, + 0x64ad0202, 0x64ad4302, 0x64ad8402, 0x64adc502, 0x65ad0202, 0x65ad4302, 0x65ad8402, 0x65adc502, + 0x66ad0202, 0x66ad4302, 0x66ad8402, 0x66adc502, 0x67ad0202, 0x67ad4302, 0x67ad8402, 0x67adc502, + 0x68ad0202, 0x68ad4302, 0x68ad8402, 0x68adc502, 0x69ad0202, 0x69ad4302, 0x69ad8402, 0x69adc502, + 0x6aad0202, 0x6aad4302, 0x6aad8402, 0x6aadc502, 0x6bad0202, 0x6bad4302, 0x6bad8402, 0x6badc502, + 0x6cad0202, 0x6cad4302, 0x6cad8402, 0x6cadc502, 0x6dad0202, 0x6dad4302, 0x6dad8402, 0x6dadc502, + 0x6ead0202, 0x6ead4302, 0x6ead8402, 0x6eadc502, 0x6fad0202, 0x6fad4302, 0x6fad8402, 0x6fadc502, + 0x70ad0202, 0x70ad4302, 0x70ad8402, 0x70adc502, 0x71ad0202, 0x71ad4302, 0x71ad8402, 0x71adc502, + 0x72ad0202, 0x72ad4302, 0x72ad8402, 0x72adc502, 0x73ad0202, 0x73ad4302, 0x73ad8402, 0x73adc502, + 0x74ad0202, 0x74ad4302, 0x74ad8402, 0x74adc502, 0x75ad0202, 0x75ad4302, 0x75ad8402, 0x75adc502, + 0x76ad0202, 0x76ad4302, 0x76ad8402, 0x76adc502, 0x77ad0202, 0x77ad4302, 0x77ad8402, 0x77adc502, + 0x78ad0202, 0x78ad4302, 0x78ad8402, 0x78adc502, 0x79ad0202, 0x79ad4302, 0x79ad8402, 0x79adc502, + 0x7aad0202, 0x7aad4302, 0x7aad8402, 0x7aadc502, 0x7bad0202, 0x7bad4302, 0x7bad8402, 0x7badc502, + 0x7cad0202, 0x7cad4302, 0x7cad8402, 0x7cadc502, 0x7dad0202, 0x7dad4302, 0x7dad8402, 0x7dadc502, + 0x7ead0202, 0x7ead4302, 0x7ead8402, 0x7eadc502, 0x7fad0202, 0x7fad4302, 0x7fad8402, 0x7fadc502, + 0x80ad0202, 0x80ad4302, 0x80ad8402, 0x80adc502, 0x81ad0202, 0x81ad4302, 0x81ad8402, 0x81adc502, + 0x82ad0202, 0x82ad4302, 0x82ad8402, 0x82adc502, 0x83ad0202, 0x83ad4302, 0x83ad8402, 0x83adc502, + 0x84ad0202, 0x84ad4302, 0x84ad8402, 0x84adc502, 0x85ad0202, 0x85ad4302, 0x85ad8402, 0x85adc502, + 0x86ad0202, 0x86ad4302, 0x86ad8402, 0x86adc502, 0x87ad0202, 0x87ad4302, 0x87ad8402, 0x87adc502, + 0x88ad0202, 0x88ad4302, 0x88ad8402, 0x88adc502, 0x89ad0202, 0x89ad4302, 0x89ad8402, 0x89adc502, + 0x8aad0202, 0x8aad4302, 0x8aad8402, 0x8aadc502, 0x8bad0202, 0x8bad4302, 0x8bad8402, 0x8badc502, + 0x8cad0202, 0x8cad4302, 0x8cad8402, 0x8cadc502, 0x8dad0202, 0x8dad4302, 0x8dad8402, 0x8dadc502, + 0x8ead0202, 0x8ead4302, 0x8ead8402, 0x8eadc502, 0x8fad0202, 0x8fad4302, 0x8fad8402, 0x8fadc502, + 0x90ad0202, 0x90ad4302, 0x90ad8402, 0x90adc502, 0x91ad0202, 0x91ad4302, 0x91ad8402, 0x91adc502, + 0x92ad0202, 0x92ad4302, 0x92ad8402, 0x92adc502, 0x93ad0202, 0x93ad4302, 0x93ad8402, 0x93adc502, + 0x94ad0202, 0x94ad4302, 0x94ad8402, 0x94adc502, 0x95ad0202, 0x95ad4302, 0x95ad8402, 0x95adc502, + 0x96ad0202, 0x96ad4302, 0x96ad8402, 0x96adc502, 0x97ad0202, 0x97ad4302, 0x97ad8402, 0x97adc502, + 0x98ad0202, 0x98ad4302, 0x98ad8402, 0x98adc502, 0x99ad0202, 0x99ad4302, 0x99ad8402, 0x99adc502, + 0x9aad0202, 0x9aad4302, 0x9aad8402, 0x9aadc502, 0x9bad0202, 0x9bad4302, 0x9bad8402, 0x9badc502, + 0x9cad0202, 0x9cad4302, 0x9cad8402, 0x9cadc502, 0x9dad0202, 0x9dad4302, 0x9dad8402, 0x9dadc502, + 0x9ead0202, 0x9ead4302, 0x9ead8402, 0x9eadc502, 0x9fad0202, 0x9fad4302, 0x9fad8402, 0x9fadc502, + 0xa0ad0202, 0xa0ad4302, 0xa0ad8402, 0xa0adc502, 0xa1ad0202, 0xa1ad4302, 0xa1ad8402, 0xa1adc502, + 0xa2ad0202, 0xa2ad4302, 0xa2ad8402, 0xa2adc502, 0xa3ad0202, 0xa3ad4302, 0xa3ad8402, 0xa3adc502, + 0xa4ad0202, 0xa4ad4302, 0xa4ad8402, 0xa4adc502, 0xa5ad0202, 0xa5ad4302, 0xa5ad8402, 0xa5adc502, + 0xa6ad0202, 0xa6ad4302, 0xa6ad8402, 0xa6adc502, 0xa7ad0202, 0xa7ad4302, 0xa7ad8402, 0xa7adc502, + 0xa8ad0202, 0xa8ad4302, 0xa8ad8402, 0xa8adc502, 0xa9ad0202, 0xa9ad4302, 0xa9ad8402, 0xa9adc502, + 0xaaad0202, 0xaaad4302, 0xaaad8402, 0xaaadc502, 0xabad0202, 0xabad4302, 0xabad8402, 0xabadc502, + 0xacad0202, 0xacad4302, 0xacad8402, 0xacadc502, 0xadad0202, 0xadad4302, 0xadad8402, 0xadadc502, + 0xaead0202, 0xaead4302, 0xaead8402, 0xaeadc502, 0xafad0202, 0xafad4302, 0xafad8402, 0xafadc502, + 0xb0ad0202, 0xb0ad4302, 0xb0ad8402, 0xb0adc502, 0xb1ad0202, 0xb1ad4302, 0xb1ad8402, 0xb1adc502, + 0xb2ad0202, 0xb2ad4302, 0xb2ad8402, 0xb2adc502, 0xb3ad0202, 0xb3ad4302, 0xb3ad8402, 0xb3adc502, + 0xb4ad0202, 0xb4ad4302, 0xb4ad8402, 0xb4adc502, 0xb5ad0202, 0xb5ad4302, 0xb5ad8402, 0xb5adc502, + 0xb6ad0202, 0xb6ad4302, 0xb6ad8402, 0xb6adc502, 0xb7ad0202, 0xb7ad4302, 0xb7ad8402, 0xb7adc502, + 0xb8ad0202, 0xb8ad4302, 0xb8ad8402, 0xb8adc502, 0xb9ad0202, 0xb9ad4302, 0xb9ad8402, 0xb9adc502, + 0xbaad0202, 0xbaad4302, 0xbaad8402, 0xbaadc502, 0xbbad0202, 0xbbad4302, 0xbbad8402, 0xbbadc502, + 0xbcad0202, 0xbcad4302, 0xbcad8402, 0xbcadc502, 0xbdad0202, 0xbdad4302, 0xbdad8402, 0xbdadc502, + 0xbead0202, 0xbead4302, 0xbead8402, 0xbeadc502, 0xbfad0202, 0xbfad4302, 0xbfad8402, 0xbfadc502, + 0xc0ad0202, 0xc0ad4302, 0xc0ad8402, 0xc0adc502, 0xc1ad0202, 0xc1ad4302, 0xc1ad8402, 0xc1adc502, + 0xc2ad0202, 0xc2ad4302, 0xc2ad8402, 0xc2adc502, 0xc3ad0202, 0xc3ad4302, 0xc3ad8402, 0xc3adc502, + 0xc4ad0202, 0xc4ad4302, 0xc4ad8402, 0xc4adc502, 0xc5ad0202, 0xc5ad4302, 0xc5ad8402, 0xc5adc502, + 0xc6ad0202, 0xc6ad4302, 0xc6ad8402, 0xc6adc502, 0xc7ad0202, 0xc7ad4302, 0xc7ad8402, 0xc7adc502, + 0xc8ad0202, 0xc8ad4302, 0xc8ad8402, 0xc8adc502, 0xc9ad0202, 0xc9ad4302, 0xc9ad8402, 0xc9adc502, + 0xcaad0202, 0xcaad4302, 0xcaad8402, 0xcaadc502, 0xcbad0202, 0xcbad4302, 0xcbad8402, 0xcbadc502, + 0xccad0202, 0xccad4302, 0xccad8402, 0xccadc502, 0xcdad0202, 0xcdad4302, 0xcdad8402, 0xcdadc502, + 0xcead0202, 0xcead4302, 0xcead8402, 0xceadc502, 0xcfad0202, 0xcfad4302, 0xcfad8402, 0xcfadc502, + 0xd0ad0202, 0xd0ad4302, 0xd0ad8402, 0xd0adc502, 0xd1ad0202, 0xd1ad4302, 0xd1ad8402, 0xd1adc502, + 0xd2ad0202, 0xd2ad4302, 0xd2ad8402, 0xd2adc502, 0xd3ad0202, 0xd3ad4302, 0xd3ad8402, 0xd3adc502, + 0xd4ad0202, 0xd4ad4302, 0xd4ad8402, 0xd4adc502, 0xd5ad0202, 0xd5ad4302, 0xd5ad8402, 0xd5adc502, + 0xd6ad0202, 0xd6ad4302, 0xd6ad8402, 0xd6adc502, 0xd7ad0202, 0xd7ad4302, 0xd7ad8402, 0xd7adc502, + 0xd8ad0202, 0xd8ad4302, 0xd8ad8402, 0xd8adc502, 0xd9ad0202, 0xd9ad4302, 0xd9ad8402, 0xd9adc502, + 0xdaad0202, 0xdaad4302, 0xdaad8402, 0xdaadc502, 0xdbad0202, 0xdbad4302, 0xdbad8402, 0xdbadc502, + 0xdcad0202, 0xdcad4302, 0xdcad8402, 0xdcadc502, 0xddad0202, 0xddad4302, 0xddad8402, 0xddadc502, + 0xdead0202, 0xdead4302, 0xdead8402, 0xdeadc502, 0xdfad0202, 0xdfad4302, 0xdfad8402, 0xdfadc502, + 0xe0ad0202, 0xe0ad4302, 0xe0ad8402, 0xe0adc502, 0xe1ad0202, 0xe1ad4302, 0xe1ad8402, 0xe1adc502, + 0xe2ad0202, 0xe2ad4302, 0xe2ad8402, 0xe2adc502, 0xe3ad0202, 0xe3ad4302, 0xe3ad8402, 0xe3adc502, + 0xe4ad0202, 0xe4ad4302, 0xe4ad8402, 0xe4adc502, 0xe5ad0202, 0xe5ad4302, 0xe5ad8402, 0xe5adc502, + 0xe6ad0202, 0xe6ad4302, 0xe6ad8402, 0xe6adc502, 0xe7ad0202, 0xe7ad4302, 0xe7ad8402, 0xe7adc502, + 0xe8ad0202, 0xe8ad4302, 0xe8ad8402, 0xe8adc502, 0xe9ad0202, 0xe9ad4302, 0xe9ad8402, 0xe9adc502, + 0xeaad0202, 0xeaad4302, 0xeaad8402, 0xeaadc502, 0xebad0202, 0xebad4302, 0xebad8402, 0xebadc502, + 0xecad0202, 0xecad4302, 0xecad8402, 0xecadc502, 0xedad0202, 0xedad4302, 0xedad8402, 0xedadc502, + 0xeead0202, 0xeead4302, 0xeead8402, 0xeeadc502, 0xefad0202, 0xefad4302, 0xefad8402, 0xefadc502, + 0xf0ad0202, 0xf0ad4302, 0xf0ad8402, 0xf0adc502, 0xf1ad0202, 0xf1ad4302, 0xf1ad8402, 0xf1adc502, + 0xf2ad0202, 0xf2ad4302, 0xf2ad8402, 0xf2adc502, 0xf3ad0202, 0xf3ad4302, 0xf3ad8402, 0xf3adc502, + 0xf4ad0202, 0xf4ad4302, 0xf4ad8402, 0xf4adc502, 0xf5ad0202, 0xf5ad4302, 0xf5ad8402, 0xf5adc502, + 0xf6ad0202, 0xf6ad4302, 0xf6ad8402, 0xf6adc502, 0xf7ad0202, 0xf7ad4302, 0xf7ad8402, 0xf7adc502, + 0xf8ad0202, 0xf8ad4302, 0xf8ad8402, 0xf8adc502, 0xf9ad0202, 0xf9ad4302, 0xf9ad8402, 0xf9adc502, + 0xfaad0202, 0xfaad4302, 0xfaad8402, 0xfaadc502, 0xfbad0202, 0xfbad4302, 0xfbad8402, 0xfbadc502, + 0xfcad0202, 0xfcad4302, 0xfcad8402, 0xfcadc502, 0xfdad0202, 0xfdad4302, 0xfdad8402, 0xfdadc502, + 0xfead0202, 0xfead4302, 0xfead8402, 0xfeadc502, 0xffad0202, 0xffad4302, 0xffad8402, 0xffadc502, + 0x02ae0202, 0x02ae4302, 0x02ae8402, 0x02aec502, 0x03ae0202, 0x03ae4302, 0x03ae8402, 0x03aec502, + 0x04ae0202, 0x04ae4302, 0x04ae8402, 0x04aec502, 0x05ae0202, 0x05ae4302, 0x05ae8402, 0x05aec502, + 0x06ae0202, 0x06ae4302, 0x06ae8402, 0x06aec502, 0x07ae0202, 0x07ae4302, 0x07ae8402, 0x07aec502, + 0x08ae0202, 0x08ae4302, 0x08ae8402, 0x08aec502, 0x09ae0202, 0x09ae4302, 0x09ae8402, 0x09aec502, + 0x0aae0202, 0x0aae4302, 0x0aae8402, 0x0aaec502, 0x0bae0202, 0x0bae4302, 0x0bae8402, 0x0baec502, + 0x0cae0202, 0x0cae4302, 0x0cae8402, 0x0caec502, 0x0dae0202, 0x0dae4302, 0x0dae8402, 0x0daec502, + 0x0eae0202, 0x0eae4302, 0x0eae8402, 0x0eaec502, 0x0fae0202, 0x0fae4302, 0x0fae8402, 0x0faec502, + 0x10ae0202, 0x10ae4302, 0x10ae8402, 0x10aec502, 0x11ae0202, 0x11ae4302, 0x11ae8402, 0x11aec502, + 0x12ae0202, 0x12ae4302, 0x12ae8402, 0x12aec502, 0x13ae0202, 0x13ae4302, 0x13ae8402, 0x13aec502, + 0x14ae0202, 0x14ae4302, 0x14ae8402, 0x14aec502, 0x15ae0202, 0x15ae4302, 0x15ae8402, 0x15aec502, + 0x16ae0202, 0x16ae4302, 0x16ae8402, 0x16aec502, 0x17ae0202, 0x17ae4302, 0x17ae8402, 0x17aec502, + 0x18ae0202, 0x18ae4302, 0x18ae8402, 0x18aec502, 0x19ae0202, 0x19ae4302, 0x19ae8402, 0x19aec502, + 0x1aae0202, 0x1aae4302, 0x1aae8402, 0x1aaec502, 0x1bae0202, 0x1bae4302, 0x1bae8402, 0x1baec502, + 0x1cae0202, 0x1cae4302, 0x1cae8402, 0x1caec502, 0x1dae0202, 0x1dae4302, 0x1dae8402, 0x1daec502, + 0x1eae0202, 0x1eae4302, 0x1eae8402, 0x1eaec502, 0x1fae0202, 0x1fae4302, 0x1fae8402, 0x1faec502, + 0x20ae0202, 0x20ae4302, 0x20ae8402, 0x20aec502, 0x21ae0202, 0x21ae4302, 0x21ae8402, 0x21aec502, + 0x22ae0202, 0x22ae4302, 0x22ae8402, 0x22aec502, 0x23ae0202, 0x23ae4302, 0x23ae8402, 0x23aec502, + 0x24ae0202, 0x24ae4302, 0x24ae8402, 0x24aec502, 0x25ae0202, 0x25ae4302, 0x25ae8402, 0x25aec502, + 0x26ae0202, 0x26ae4302, 0x26ae8402, 0x26aec502, 0x27ae0202, 0x27ae4302, 0x27ae8402, 0x27aec502, + 0x28ae0202, 0x28ae4302, 0x28ae8402, 0x28aec502, 0x29ae0202, 0x29ae4302, 0x29ae8402, 0x29aec502, + 0x2aae0202, 0x2aae4302, 0x2aae8402, 0x2aaec502, 0x2bae0202, 0x2bae4302, 0x2bae8402, 0x2baec502, + 0x2cae0202, 0x2cae4302, 0x2cae8402, 0x2caec502, 0x2dae0202, 0x2dae4302, 0x2dae8402, 0x2daec502, + 0x2eae0202, 0x2eae4302, 0x2eae8402, 0x2eaec502, 0x2fae0202, 0x2fae4302, 0x2fae8402, 0x2faec502, + 0x30ae0202, 0x30ae4302, 0x30ae8402, 0x30aec502, 0x31ae0202, 0x31ae4302, 0x31ae8402, 0x31aec502, + 0x32ae0202, 0x32ae4302, 0x32ae8402, 0x32aec502, 0x33ae0202, 0x33ae4302, 0x33ae8402, 0x33aec502, + 0x34ae0202, 0x34ae4302, 0x34ae8402, 0x34aec502, 0x35ae0202, 0x35ae4302, 0x35ae8402, 0x35aec502, + 0x36ae0202, 0x36ae4302, 0x36ae8402, 0x36aec502, 0x37ae0202, 0x37ae4302, 0x37ae8402, 0x37aec502, + 0x38ae0202, 0x38ae4302, 0x38ae8402, 0x38aec502, 0x39ae0202, 0x39ae4302, 0x39ae8402, 0x39aec502, + 0x3aae0202, 0x3aae4302, 0x3aae8402, 0x3aaec502, 0x3bae0202, 0x3bae4302, 0x3bae8402, 0x3baec502, + 0x3cae0202, 0x3cae4302, 0x3cae8402, 0x3caec502, 0x3dae0202, 0x3dae4302, 0x3dae8402, 0x3daec502, + 0x3eae0202, 0x3eae4302, 0x3eae8402, 0x3eaec502, 0x3fae0202, 0x3fae4302, 0x3fae8402, 0x3faec502, + 0x40ae0202, 0x40ae4302, 0x40ae8402, 0x40aec502, 0x41ae0202, 0x41ae4302, 0x41ae8402, 0x41aec502, + 0x42ae0202, 0x42ae4302, 0x42ae8402, 0x42aec502, 0x43ae0202, 0x43ae4302, 0x43ae8402, 0x43aec502, + 0x44ae0202, 0x44ae4302, 0x44ae8402, 0x44aec502, 0x45ae0202, 0x45ae4302, 0x45ae8402, 0x45aec502, + 0x46ae0202, 0x46ae4302, 0x46ae8402, 0x46aec502, 0x47ae0202, 0x47ae4302, 0x47ae8402, 0x47aec502, + 0x48ae0202, 0x48ae4302, 0x48ae8402, 0x48aec502, 0x49ae0202, 0x49ae4302, 0x49ae8402, 0x49aec502, + 0x4aae0202, 0x4aae4302, 0x4aae8402, 0x4aaec502, 0x4bae0202, 0x4bae4302, 0x4bae8402, 0x4baec502, + 0x4cae0202, 0x4cae4302, 0x4cae8402, 0x4caec502, 0x4dae0202, 0x4dae4302, 0x4dae8402, 0x4daec502, + 0x4eae0202, 0x4eae4302, 0x4eae8402, 0x4eaec502, 0x4fae0202, 0x4fae4302, 0x4fae8402, 0x4faec502, + 0x50ae0202, 0x50ae4302, 0x50ae8402, 0x50aec502, 0x51ae0202, 0x51ae4302, 0x51ae8402, 0x51aec502, + 0x52ae0202, 0x52ae4302, 0x52ae8402, 0x52aec502, 0x53ae0202, 0x53ae4302, 0x53ae8402, 0x53aec502, + 0x54ae0202, 0x54ae4302, 0x54ae8402, 0x54aec502, 0x55ae0202, 0x55ae4302, 0x55ae8402, 0x55aec502, + 0x56ae0202, 0x56ae4302, 0x56ae8402, 0x56aec502, 0x57ae0202, 0x57ae4302, 0x57ae8402, 0x57aec502, + 0x58ae0202, 0x58ae4302, 0x58ae8402, 0x58aec502, 0x59ae0202, 0x59ae4302, 0x59ae8402, 0x59aec502, + 0x5aae0202, 0x5aae4302, 0x5aae8402, 0x5aaec502, 0x5bae0202, 0x5bae4302, 0x5bae8402, 0x5baec502, + 0x5cae0202, 0x5cae4302, 0x5cae8402, 0x5caec502, 0x5dae0202, 0x5dae4302, 0x5dae8402, 0x5daec502, + 0x5eae0202, 0x5eae4302, 0x5eae8402, 0x5eaec502, 0x5fae0202, 0x5fae4302, 0x5fae8402, 0x5faec502, + 0x60ae0202, 0x60ae4302, 0x60ae8402, 0x60aec502, 0x61ae0202, 0x61ae4302, 0x61ae8402, 0x61aec502, + 0x62ae0202, 0x62ae4302, 0x62ae8402, 0x62aec502, 0x63ae0202, 0x63ae4302, 0x63ae8402, 0x63aec502, + 0x64ae0202, 0x64ae4302, 0x64ae8402, 0x64aec502, 0x65ae0202, 0x65ae4302, 0x65ae8402, 0x65aec502, + 0x66ae0202, 0x66ae4302, 0x66ae8402, 0x66aec502, 0x67ae0202, 0x67ae4302, 0x67ae8402, 0x67aec502, + 0x68ae0202, 0x68ae4302, 0x68ae8402, 0x68aec502, 0x69ae0202, 0x69ae4302, 0x69ae8402, 0x69aec502, + 0x6aae0202, 0x6aae4302, 0x6aae8402, 0x6aaec502, 0x6bae0202, 0x6bae4302, 0x6bae8402, 0x6baec502, + 0x6cae0202, 0x6cae4302, 0x6cae8402, 0x6caec502, 0x6dae0202, 0x6dae4302, 0x6dae8402, 0x6daec502, + 0x6eae0202, 0x6eae4302, 0x6eae8402, 0x6eaec502, 0x6fae0202, 0x6fae4302, 0x6fae8402, 0x6faec502, + 0x70ae0202, 0x70ae4302, 0x70ae8402, 0x70aec502, 0x71ae0202, 0x71ae4302, 0x71ae8402, 0x71aec502, + 0x72ae0202, 0x72ae4302, 0x72ae8402, 0x72aec502, 0x73ae0202, 0x73ae4302, 0x73ae8402, 0x73aec502, + 0x74ae0202, 0x74ae4302, 0x74ae8402, 0x74aec502, 0x75ae0202, 0x75ae4302, 0x75ae8402, 0x75aec502, + 0x76ae0202, 0x76ae4302, 0x76ae8402, 0x76aec502, 0x77ae0202, 0x77ae4302, 0x77ae8402, 0x77aec502, + 0x78ae0202, 0x78ae4302, 0x78ae8402, 0x78aec502, 0x79ae0202, 0x79ae4302, 0x79ae8402, 0x79aec502, + 0x7aae0202, 0x7aae4302, 0x7aae8402, 0x7aaec502, 0x7bae0202, 0x7bae4302, 0x7bae8402, 0x7baec502, + 0x7cae0202, 0x7cae4302, 0x7cae8402, 0x7caec502, 0x7dae0202, 0x7dae4302, 0x7dae8402, 0x7daec502, + 0x7eae0202, 0x7eae4302, 0x7eae8402, 0x7eaec502, 0x7fae0202, 0x7fae4302, 0x7fae8402, 0x7faec502, + 0x80ae0202, 0x80ae4302, 0x80ae8402, 0x80aec502, 0x81ae0202, 0x81ae4302, 0x81ae8402, 0x81aec502, + 0x82ae0202, 0x82ae4302, 0x82ae8402, 0x82aec502, 0x83ae0202, 0x83ae4302, 0x83ae8402, 0x83aec502, + 0x84ae0202, 0x84ae4302, 0x84ae8402, 0x84aec502, 0x85ae0202, 0x85ae4302, 0x85ae8402, 0x85aec502, + 0x86ae0202, 0x86ae4302, 0x86ae8402, 0x86aec502, 0x87ae0202, 0x87ae4302, 0x87ae8402, 0x87aec502, + 0x88ae0202, 0x88ae4302, 0x88ae8402, 0x88aec502, 0x89ae0202, 0x89ae4302, 0x89ae8402, 0x89aec502, + 0x8aae0202, 0x8aae4302, 0x8aae8402, 0x8aaec502, 0x8bae0202, 0x8bae4302, 0x8bae8402, 0x8baec502, + 0x8cae0202, 0x8cae4302, 0x8cae8402, 0x8caec502, 0x8dae0202, 0x8dae4302, 0x8dae8402, 0x8daec502, + 0x8eae0202, 0x8eae4302, 0x8eae8402, 0x8eaec502, 0x8fae0202, 0x8fae4302, 0x8fae8402, 0x8faec502, + 0x90ae0202, 0x90ae4302, 0x90ae8402, 0x90aec502, 0x91ae0202, 0x91ae4302, 0x91ae8402, 0x91aec502, + 0x92ae0202, 0x92ae4302, 0x92ae8402, 0x92aec502, 0x93ae0202, 0x93ae4302, 0x93ae8402, 0x93aec502, + 0x94ae0202, 0x94ae4302, 0x94ae8402, 0x94aec502, 0x95ae0202, 0x95ae4302, 0x95ae8402, 0x95aec502, + 0x96ae0202, 0x96ae4302, 0x96ae8402, 0x96aec502, 0x97ae0202, 0x97ae4302, 0x97ae8402, 0x97aec502, + 0x98ae0202, 0x98ae4302, 0x98ae8402, 0x98aec502, 0x99ae0202, 0x99ae4302, 0x99ae8402, 0x99aec502, + 0x9aae0202, 0x9aae4302, 0x9aae8402, 0x9aaec502, 0x9bae0202, 0x9bae4302, 0x9bae8402, 0x9baec502, + 0x9cae0202, 0x9cae4302, 0x9cae8402, 0x9caec502, 0x9dae0202, 0x9dae4302, 0x9dae8402, 0x9daec502, + 0x9eae0202, 0x9eae4302, 0x9eae8402, 0x9eaec502, 0x9fae0202, 0x9fae4302, 0x9fae8402, 0x9faec502, + 0xa0ae0202, 0xa0ae4302, 0xa0ae8402, 0xa0aec502, 0xa1ae0202, 0xa1ae4302, 0xa1ae8402, 0xa1aec502, + 0xa2ae0202, 0xa2ae4302, 0xa2ae8402, 0xa2aec502, 0xa3ae0202, 0xa3ae4302, 0xa3ae8402, 0xa3aec502, + 0xa4ae0202, 0xa4ae4302, 0xa4ae8402, 0xa4aec502, 0xa5ae0202, 0xa5ae4302, 0xa5ae8402, 0xa5aec502, + 0xa6ae0202, 0xa6ae4302, 0xa6ae8402, 0xa6aec502, 0xa7ae0202, 0xa7ae4302, 0xa7ae8402, 0xa7aec502, + 0xa8ae0202, 0xa8ae4302, 0xa8ae8402, 0xa8aec502, 0xa9ae0202, 0xa9ae4302, 0xa9ae8402, 0xa9aec502, + 0xaaae0202, 0xaaae4302, 0xaaae8402, 0xaaaec502, 0xabae0202, 0xabae4302, 0xabae8402, 0xabaec502, + 0xacae0202, 0xacae4302, 0xacae8402, 0xacaec502, 0xadae0202, 0xadae4302, 0xadae8402, 0xadaec502, + 0xaeae0202, 0xaeae4302, 0xaeae8402, 0xaeaec502, 0xafae0202, 0xafae4302, 0xafae8402, 0xafaec502, + 0xb0ae0202, 0xb0ae4302, 0xb0ae8402, 0xb0aec502, 0xb1ae0202, 0xb1ae4302, 0xb1ae8402, 0xb1aec502, + 0xb2ae0202, 0xb2ae4302, 0xb2ae8402, 0xb2aec502, 0xb3ae0202, 0xb3ae4302, 0xb3ae8402, 0xb3aec502, + 0xb4ae0202, 0xb4ae4302, 0xb4ae8402, 0xb4aec502, 0xb5ae0202, 0xb5ae4302, 0xb5ae8402, 0xb5aec502, + 0xb6ae0202, 0xb6ae4302, 0xb6ae8402, 0xb6aec502, 0xb7ae0202, 0xb7ae4302, 0xb7ae8402, 0xb7aec502, + 0xb8ae0202, 0xb8ae4302, 0xb8ae8402, 0xb8aec502, 0xb9ae0202, 0xb9ae4302, 0xb9ae8402, 0xb9aec502, + 0xbaae0202, 0xbaae4302, 0xbaae8402, 0xbaaec502, 0xbbae0202, 0xbbae4302, 0xbbae8402, 0xbbaec502, + 0xbcae0202, 0xbcae4302, 0xbcae8402, 0xbcaec502, 0xbdae0202, 0xbdae4302, 0xbdae8402, 0xbdaec502, + 0xbeae0202, 0xbeae4302, 0xbeae8402, 0xbeaec502, 0xbfae0202, 0xbfae4302, 0xbfae8402, 0xbfaec502, + 0xc0ae0202, 0xc0ae4302, 0xc0ae8402, 0xc0aec502, 0xc1ae0202, 0xc1ae4302, 0xc1ae8402, 0xc1aec502, + 0xc2ae0202, 0xc2ae4302, 0xc2ae8402, 0xc2aec502, 0xc3ae0202, 0xc3ae4302, 0xc3ae8402, 0xc3aec502, + 0xc4ae0202, 0xc4ae4302, 0xc4ae8402, 0xc4aec502, 0xc5ae0202, 0xc5ae4302, 0xc5ae8402, 0xc5aec502, + 0xc6ae0202, 0xc6ae4302, 0xc6ae8402, 0xc6aec502, 0xc7ae0202, 0xc7ae4302, 0xc7ae8402, 0xc7aec502, + 0xc8ae0202, 0xc8ae4302, 0xc8ae8402, 0xc8aec502, 0xc9ae0202, 0xc9ae4302, 0xc9ae8402, 0xc9aec502, + 0xcaae0202, 0xcaae4302, 0xcaae8402, 0xcaaec502, 0xcbae0202, 0xcbae4302, 0xcbae8402, 0xcbaec502, + 0xccae0202, 0xccae4302, 0xccae8402, 0xccaec502, 0xcdae0202, 0xcdae4302, 0xcdae8402, 0xcdaec502, + 0xceae0202, 0xceae4302, 0xceae8402, 0xceaec502, 0xcfae0202, 0xcfae4302, 0xcfae8402, 0xcfaec502, + 0xd0ae0202, 0xd0ae4302, 0xd0ae8402, 0xd0aec502, 0xd1ae0202, 0xd1ae4302, 0xd1ae8402, 0xd1aec502, + 0xd2ae0202, 0xd2ae4302, 0xd2ae8402, 0xd2aec502, 0xd3ae0202, 0xd3ae4302, 0xd3ae8402, 0xd3aec502, + 0xd4ae0202, 0xd4ae4302, 0xd4ae8402, 0xd4aec502, 0xd5ae0202, 0xd5ae4302, 0xd5ae8402, 0xd5aec502, + 0xd6ae0202, 0xd6ae4302, 0xd6ae8402, 0xd6aec502, 0xd7ae0202, 0xd7ae4302, 0xd7ae8402, 0xd7aec502, + 0xd8ae0202, 0xd8ae4302, 0xd8ae8402, 0xd8aec502, 0xd9ae0202, 0xd9ae4302, 0xd9ae8402, 0xd9aec502, + 0xdaae0202, 0xdaae4302, 0xdaae8402, 0xdaaec502, 0xdbae0202, 0xdbae4302, 0xdbae8402, 0xdbaec502, + 0xdcae0202, 0xdcae4302, 0xdcae8402, 0xdcaec502, 0xddae0202, 0xddae4302, 0xddae8402, 0xddaec502, + 0xdeae0202, 0xdeae4302, 0xdeae8402, 0xdeaec502, 0xdfae0202, 0xdfae4302, 0xdfae8402, 0xdfaec502, + 0xe0ae0202, 0xe0ae4302, 0xe0ae8402, 0xe0aec502, 0xe1ae0202, 0xe1ae4302, 0xe1ae8402, 0xe1aec502, + 0xe2ae0202, 0xe2ae4302, 0xe2ae8402, 0xe2aec502, 0xe3ae0202, 0xe3ae4302, 0xe3ae8402, 0xe3aec502, + 0xe4ae0202, 0xe4ae4302, 0xe4ae8402, 0xe4aec502, 0xe5ae0202, 0xe5ae4302, 0xe5ae8402, 0xe5aec502, + 0xe6ae0202, 0xe6ae4302, 0xe6ae8402, 0xe6aec502, 0xe7ae0202, 0xe7ae4302, 0xe7ae8402, 0xe7aec502, + 0xe8ae0202, 0xe8ae4302, 0xe8ae8402, 0xe8aec502, 0xe9ae0202, 0xe9ae4302, 0xe9ae8402, 0xe9aec502, + 0xeaae0202, 0xeaae4302, 0xeaae8402, 0xeaaec502, 0xebae0202, 0xebae4302, 0xebae8402, 0xebaec502, + 0xecae0202, 0xecae4302, 0xecae8402, 0xecaec502, 0xedae0202, 0xedae4302, 0xedae8402, 0xedaec502, + 0xeeae0202, 0xeeae4302, 0xeeae8402, 0xeeaec502, 0xefae0202, 0xefae4302, 0xefae8402, 0xefaec502, + 0xf0ae0202, 0xf0ae4302, 0xf0ae8402, 0xf0aec502, 0xf1ae0202, 0xf1ae4302, 0xf1ae8402, 0xf1aec502, + 0xf2ae0202, 0xf2ae4302, 0xf2ae8402, 0xf2aec502, 0xf3ae0202, 0xf3ae4302, 0xf3ae8402, 0xf3aec502, + 0xf4ae0202, 0xf4ae4302, 0xf4ae8402, 0xf4aec502, 0xf5ae0202, 0xf5ae4302, 0xf5ae8402, 0xf5aec502, + 0xf6ae0202, 0xf6ae4302, 0xf6ae8402, 0xf6aec502, 0xf7ae0202, 0xf7ae4302, 0xf7ae8402, 0xf7aec502, + 0xf8ae0202, 0xf8ae4302, 0xf8ae8402, 0xf8aec502, 0xf9ae0202, 0xf9ae4302, 0xf9ae8402, 0xf9aec502, + 0xfaae0202, 0xfaae4302, 0xfaae8402, 0xfaaec502, 0xfbae0202, 0xfbae4302, 0xfbae8402, 0xfbaec502, + 0xfcae0202, 0xfcae4302, 0xfcae8402, 0xfcaec502, 0xfdae0202, 0xfdae4302, 0xfdae8402, 0xfdaec502, + 0xfeae0202, 0xfeae4302, 0xfeae8402, 0xfeaec502, 0xffae0202, 0xffae4302, 0xffae8402, 0xffaec502, + 0x02af0202, 0x02af4302, 0x02af8402, 0x02afc502, 0x03af0202, 0x03af4302, 0x03af8402, 0x03afc502, + 0x04af0202, 0x04af4302, 0x04af8402, 0x04afc502, 0x05af0202, 0x05af4302, 0x05af8402, 0x05afc502, + 0x06af0202, 0x06af4302, 0x06af8402, 0x06afc502, 0x07af0202, 0x07af4302, 0x07af8402, 0x07afc502, + 0x08af0202, 0x08af4302, 0x08af8402, 0x08afc502, 0x09af0202, 0x09af4302, 0x09af8402, 0x09afc502, + 0x0aaf0202, 0x0aaf4302, 0x0aaf8402, 0x0aafc502, 0x0baf0202, 0x0baf4302, 0x0baf8402, 0x0bafc502, + 0x0caf0202, 0x0caf4302, 0x0caf8402, 0x0cafc502, 0x0daf0202, 0x0daf4302, 0x0daf8402, 0x0dafc502, + 0x0eaf0202, 0x0eaf4302, 0x0eaf8402, 0x0eafc502, 0x0faf0202, 0x0faf4302, 0x0faf8402, 0x0fafc502, + 0x10af0202, 0x10af4302, 0x10af8402, 0x10afc502, 0x11af0202, 0x11af4302, 0x11af8402, 0x11afc502, + 0x12af0202, 0x12af4302, 0x12af8402, 0x12afc502, 0x13af0202, 0x13af4302, 0x13af8402, 0x13afc502, + 0x14af0202, 0x14af4302, 0x14af8402, 0x14afc502, 0x15af0202, 0x15af4302, 0x15af8402, 0x15afc502, + 0x16af0202, 0x16af4302, 0x16af8402, 0x16afc502, 0x17af0202, 0x17af4302, 0x17af8402, 0x17afc502, + 0x18af0202, 0x18af4302, 0x18af8402, 0x18afc502, 0x19af0202, 0x19af4302, 0x19af8402, 0x19afc502, + 0x1aaf0202, 0x1aaf4302, 0x1aaf8402, 0x1aafc502, 0x1baf0202, 0x1baf4302, 0x1baf8402, 0x1bafc502, + 0x1caf0202, 0x1caf4302, 0x1caf8402, 0x1cafc502, 0x1daf0202, 0x1daf4302, 0x1daf8402, 0x1dafc502, + 0x1eaf0202, 0x1eaf4302, 0x1eaf8402, 0x1eafc502, 0x1faf0202, 0x1faf4302, 0x1faf8402, 0x1fafc502, + 0x20af0202, 0x20af4302, 0x20af8402, 0x20afc502, 0x21af0202, 0x21af4302, 0x21af8402, 0x21afc502, + 0x22af0202, 0x22af4302, 0x22af8402, 0x22afc502, 0x23af0202, 0x23af4302, 0x23af8402, 0x23afc502, + 0x24af0202, 0x24af4302, 0x24af8402, 0x24afc502, 0x25af0202, 0x25af4302, 0x25af8402, 0x25afc502, + 0x26af0202, 0x26af4302, 0x26af8402, 0x26afc502, 0x27af0202, 0x27af4302, 0x27af8402, 0x27afc502, + 0x28af0202, 0x28af4302, 0x28af8402, 0x28afc502, 0x29af0202, 0x29af4302, 0x29af8402, 0x29afc502, + 0x2aaf0202, 0x2aaf4302, 0x2aaf8402, 0x2aafc502, 0x2baf0202, 0x2baf4302, 0x2baf8402, 0x2bafc502, + 0x2caf0202, 0x2caf4302, 0x2caf8402, 0x2cafc502, 0x2daf0202, 0x2daf4302, 0x2daf8402, 0x2dafc502, + 0x2eaf0202, 0x2eaf4302, 0x2eaf8402, 0x2eafc502, 0x2faf0202, 0x2faf4302, 0x2faf8402, 0x2fafc502, + 0x30af0202, 0x30af4302, 0x30af8402, 0x30afc502, 0x31af0202, 0x31af4302, 0x31af8402, 0x31afc502, + 0x32af0202, 0x32af4302, 0x32af8402, 0x32afc502, 0x33af0202, 0x33af4302, 0x33af8402, 0x33afc502, + 0x34af0202, 0x34af4302, 0x34af8402, 0x34afc502, 0x35af0202, 0x35af4302, 0x35af8402, 0x35afc502, + 0x36af0202, 0x36af4302, 0x36af8402, 0x36afc502, 0x37af0202, 0x37af4302, 0x37af8402, 0x37afc502, + 0x38af0202, 0x38af4302, 0x38af8402, 0x38afc502, 0x39af0202, 0x39af4302, 0x39af8402, 0x39afc502, + 0x3aaf0202, 0x3aaf4302, 0x3aaf8402, 0x3aafc502, 0x3baf0202, 0x3baf4302, 0x3baf8402, 0x3bafc502, + 0x3caf0202, 0x3caf4302, 0x3caf8402, 0x3cafc502, 0x3daf0202, 0x3daf4302, 0x3daf8402, 0x3dafc502, + 0x3eaf0202, 0x3eaf4302, 0x3eaf8402, 0x3eafc502, 0x3faf0202, 0x3faf4302, 0x3faf8402, 0x3fafc502, + 0x40af0202, 0x40af4302, 0x40af8402, 0x40afc502, 0x41af0202, 0x41af4302, 0x41af8402, 0x41afc502, + 0x42af0202, 0x42af4302, 0x42af8402, 0x42afc502, 0x43af0202, 0x43af4302, 0x43af8402, 0x43afc502, + 0x44af0202, 0x44af4302, 0x44af8402, 0x44afc502, 0x45af0202, 0x45af4302, 0x45af8402, 0x45afc502, + 0x46af0202, 0x46af4302, 0x46af8402, 0x46afc502, 0x47af0202, 0x47af4302, 0x47af8402, 0x47afc502, + 0x48af0202, 0x48af4302, 0x48af8402, 0x48afc502, 0x49af0202, 0x49af4302, 0x49af8402, 0x49afc502, + 0x4aaf0202, 0x4aaf4302, 0x4aaf8402, 0x4aafc502, 0x4baf0202, 0x4baf4302, 0x4baf8402, 0x4bafc502, + 0x4caf0202, 0x4caf4302, 0x4caf8402, 0x4cafc502, 0x4daf0202, 0x4daf4302, 0x4daf8402, 0x4dafc502, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0xa805f202, 0xa805f502, 0xa805f402, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xa805eb02, + 0xa805ea02, 0xa805ec02, 0x00000000, 0x00000000, 0x00000000, 0xa805ed02, 0xa805ee02, 0xa805ef02, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00013200, 0x0c280202, + 0x14280a02, 0x02280203, 0x05280203, 0x06280203, 0x0d280203, 0x0e280203, 0x0f280213, 0x1a280203, + 0x1c280203, 0x00000000, 0x00000000, 0x00000000, 0x1b286202, 0x1b286302, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0b075102, 0x0c075102, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x6f290202, 0x6f290202, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0xa8290202, 0xa8290202, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0xab290202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x880b0202, 0x820b0202, 0x8a0b0202, 0x8b0b0202, 0x8c0b0202, 0x8e0b0202, 0x8f0b0202, 0x960b0202, + 0x860b0202, 0x00000000, 0x850b0202, 0x840b0202, 0x9c070202, 0x830b0202, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xdc0c0202, 0xdd0c0202, 0xde0c0202, 0xdf0c0202, 0xe00c0202, 0xe10c0202, 0xe20c0202, 0xe30c0202, + 0xe40c0202, 0xe50c0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00011700, 0x00011700, 0x00011700, 0x00011700, 0x00011800, 0x00011900, 0x00011a00, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x290b0e0c, 0x9006020c, 0x8906020c, 0x8d070202, 0x92070202, 0x28070202, 0x2b070202, 0x4b070202, + 0x4f070202, 0xa9070202, 0xac070202, 0xa4070202, 0xa6070202, 0x98070202, 0x9a070202, 0x94070202, + 0x96070202, 0x9c070202, 0x9e07020c, 0xa0070202, 0xa2070202, 0x85070202, 0x86071402, 0x1707020c, + 0x1907020c, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x45070202, 0x46070202, 0x47070202, + 0x2e070202, 0x30070202, 0x32070202, 0x00000000, 0x39070202, 0x36070202, 0x3b070202, 0x1b070202, + 0x9006020a, 0x26070202, 0x29070202, 0x49070202, 0x4d070202, 0xa7070202, 0xaa070202, 0x1e070202, + 0x24070202, 0x2c070202, 0x0308020a, 0x8206020a, 0x0e08020a, 0x1408020a, 0x1208020a, 0x00000000, + 0x40070202, 0x20070202, 0x22070202, 0x3d070202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x9a0b0202, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x1c070203, 0x1d070203, 0x1f070203, 0x21070203, 0x23070203, 0x25070203, 0x80060203, + 0x27070203, 0x2a070203, 0x2d070203, 0x03080203, 0x2f070203, 0x82060203, 0x33070203, 0x35070203, + 0x030d0203, 0x1a0d0203, 0x1c0d0203, 0x1e0d0203, 0x200d0203, 0x220d0203, 0x240d0203, 0x260d0203, + 0x280d0203, 0x2a0d0203, 0x37070203, 0x3a070203, 0x0e080203, 0x12080203, 0x14080203, 0x3c070203, + 0x3e070203, 0x020e0213, 0x090e0213, 0x0a0e0213, 0x1a0e0213, 0x210e0213, 0x230e0213, 0x250e0213, + 0x2c0e0213, 0x320e0213, 0x350e0213, 0x360e0213, 0x480e0213, 0x510e0213, 0x700e0213, 0x7c0e0213, + 0x7e0e0213, 0x890e0213, 0x8a0e0213, 0x910e0213, 0x990e0213, 0x9f0e0213, 0xa20e0213, 0xa40e0213, + 0xa60e0213, 0xa70e0213, 0xa90e0213, 0x3f070203, 0x41070203, 0x42070203, 0x43070203, 0x44070203, + 0x48070203, 0x020e0203, 0x090e0203, 0x0a0e0203, 0x1a0e0203, 0x210e0203, 0x230e0203, 0x250e0203, + 0x2c0e0203, 0x320e0203, 0x350e0203, 0x360e0203, 0x480e0203, 0x510e0203, 0x700e0203, 0x7c0e0203, + 0x7e0e0203, 0x890e0203, 0x8a0e0203, 0x910e0203, 0x990e0203, 0x9f0e0203, 0xa20e0203, 0xa40e0203, + 0xa60e0203, 0xa70e0203, 0xa90e0203, 0x4a070203, 0x4c070203, 0x4e070203, 0x50070203, 0x0b074303, + 0x0c074303, 0x34070202, 0x9b070202, 0x9d070202, 0x31070202, 0x0e0a0202, 0x4e030206, 0x02030204, + 0x03030204, 0x04030204, 0x05030204, 0x06030204, 0x3a030204, 0x3c030204, 0x3e030204, 0x1c030204, + 0x01030206, 0x02030206, 0x03030206, 0x04030206, 0x05030206, 0x06030206, 0x0a030206, 0x0b030206, + 0x0c030206, 0x0d030206, 0x0e030206, 0x12030206, 0x13030206, 0x14030206, 0x15030206, 0x16030206, + 0x1a030206, 0x1b030206, 0x1c030206, 0x1d030206, 0x1e030206, 0x22030206, 0x23030206, 0x24030206, + 0x25030206, 0x26030206, 0x2a030206, 0x2b030206, 0x2c030206, 0x2d030206, 0x2e030206, 0x32030206, + 0x33030206, 0x34030206, 0x35030206, 0x36030206, 0x3a030206, 0x3c030206, 0x3e030206, 0x42030206, + 0x43030206, 0x44030206, 0x45030206, 0x46030206, 0x4a030206, 0x80030206, 0x00010300, 0x00010400, + 0x9fed0206, 0x02c00206, 0x55c20206, 0xa7c40206, 0xa9c40206, 0x04c70206, 0x06c70206, 0x07c70206, + 0x61c90206, 0xb3cb0206, 0x06ce0206, 0x0cce0206, 0x0fce0206, 0x13ce0206, 0x17ce0206, 0x18ce0206, + 0x19ce0206, 0x1cce0206, 0x76d00206, 0xccd20206, 0x1fd50206, 0x2cd50206, 0x86d70206, 0xe4d90206, + 0x48dc0206, 0x9fde0206, 0xf4e00206, 0x4ce30206, 0x9de50206, 0xefe70206, 0x46ea0206, 0x00000000, + 0x00000000, 0x00000000, 0xa0ed0206, 0xa3ed0206, 0xa4ed0206, 0xa7ed0206, 0xa8ed0206, 0xaced0206, + 0x00000000, 0x00000000, 0xaded0206, 0xb0ed0206, 0xb1ed0206, 0xb2ed0206, 0xb3ed0206, 0xb9ed0206, + 0x00000000, 0x00000000, 0xbaed0206, 0xc0ed0206, 0xc3ed0206, 0xc5ed0206, 0xc8ed0206, 0xc9ed0206, + 0x00000000, 0x00000000, 0xd1ed0206, 0xd5ed0206, 0xd7ed0206, 0x00000000, 0x00000000, 0x00000000, + 0x97070203, 0x98070203, 0x080a0203, 0x54070203, 0x52070203, 0x9a070203, 0xa4070203, 0x00000000, + 0xe8090302, 0xdf090302, 0xd9090302, 0xdb090302, 0xdd090302, 0xbc090302, 0xc9090302, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, +] diff --git a/dissect/database/ese/table.py b/dissect/database/ese/table.py new file mode 100644 index 0000000..6a70afd --- /dev/null +++ b/dissect/database/ese/table.py @@ -0,0 +1,386 @@ +from __future__ import annotations + +import struct +from functools import cached_property +from typing import TYPE_CHECKING, Any + +from dissect.database.ese import compression +from dissect.database.ese.btree import BTree +from dissect.database.ese.c_ese import ( + CODEPAGE, + SYSOBJ, + JET_coltyp, +) +from dissect.database.ese.exception import NoNeighbourPageError +from dissect.database.ese.index import Index +from dissect.database.ese.record import Record +from dissect.database.ese.util import COLUMN_TYPE_MAP, ColumnType, RecordValue + +if TYPE_CHECKING: + from collections.abc import Iterator + + from dissect.database.ese.cursor import Cursor + from dissect.database.ese.ese import ESE + from dissect.database.ese.page import Page + + +class Table: + """Represents a table in an ESE database. + + Contains all the relevant metadata of the table, as well as all columns and indices that have been added + by the catalog. + + Args: + db: An instance of :class:`~dissect.database.ese.ese.ESE`. + name: The table name. + root_page: The root page of the table. + columns: A list of :class:`Column` for this table. + indexes: A list of :class:`~dissect.database.ese.index.Index` for this table. + record: The :class:`~dissect.database.ese.record.Record` of this table from the catalog table. + """ + + def __init__( + self, + db: ESE, + name: str, + root_page: int, + columns: list[Column] | None = None, + indexes: list[Index] | None = None, + record: Record = None, + ): + self.db = db + + self._column_name_map: dict[str, Column] = {} + self._column_id_map: dict[int, Column] = {} + self._index_name_map: dict[str, Index] = {} + + self.name = name + self.root_page = root_page + self.columns: list[Column] = [] + self.indexes: list[Index] = [] + + # Set by the catalog during parsing + self._long_value_record: Record = None + self._long_callback_record: Record = None + + self._fixed_value_offset = 0 + + columns = columns or [] + for column in columns: + self._add_column(column) + + indexes = indexes or [] + for index in indexes: + self._add_index(index) + + self.record = record + + def __repr__(self) -> str: + return f"" + + @cached_property + def root(self) -> Page: + """Return the root page of the table.""" + return self.db.page(self.root_page) + + @cached_property + def lv_page(self) -> Page: + """Return the long value page of the table. + + Raises: + TypeError: If the table has no long values. + """ + if not self._long_value_record: + raise TypeError(f"Table has no long values: {self.name}") + + return self.db.page(self._long_value_record.get("ColtypOrPgnoFDP")) + + def column(self, name: str) -> Column: + """Return the column with the given name. + + Args: + name: The name of the column to return. + + Raises: + KeyError: If no column with the given name exists. + """ + try: + return self._column_name_map[name] + except KeyError: + raise KeyError(f"No column with this name in table {self.name}: {name}") + + @property + def column_names(self) -> list[str]: + """Return a list of all the column names.""" + return list(self._column_name_map.keys()) + + @property + def primary_index(self) -> Index | None: + # It's generally the first index, but loop just in case + for index in self.indexes: + if index.is_primary: + return index + return None + + def cursor(self) -> Cursor | None: + """Create a new cursor for this table.""" + primary_idx = self.primary_index + if primary_idx: + return primary_idx.cursor() + return None + + def index(self, name: str) -> Index: + """Return the index with the given ``name``. + + Args: + name: The name of the index to return. + + Raises: + KeyError: If no index with the given name exists. + """ + try: + return self._index_name_map[name] + except KeyError: + raise KeyError(f"No index with this name in table {self.name}: {name}") + + def find_index(self, column_names: list[str]) -> Index | None: + """Find the most suitable index to search for the given columns. + + Args: + column_names: A list of column names to find the best index for. + """ + best_match = 0 + best_index = None + for index in self.indexes: + # We want to find the index that has the most matching columns in the order they are indexed + i = 0 + for column in index.columns: + if column.name not in column_names: + break + i += 1 + + if i > best_match: + best_index = index + best_match = i + + return best_index + + def search(self, **kwargs: RecordValue) -> Record | None: + """Search for a record in the table. + + Args: + **kwargs: The columns and values to search for. + + Returns: + The first record that matches the search criteria, or ``None`` if no record was found. + """ + return self.cursor().search(**kwargs) + + def records(self) -> Iterator[Record]: + """Return an iterator of all the records of the table.""" + for node in self.root.iter_leaf_nodes(): + yield Record(self, node) + + def get_long_value(self, key: bytes) -> bytes: + """Retrieve a value from the long value page of the table. + + Args: + key: The lookup key for the long value. + """ + rkey = key[::-1] + btree = BTree(self.db, self.lv_page) + header = btree.search(rkey) + + _, size = struct.unpack("<2I", header.data) + chunks = [] + chunk_offsets = [] + + while True: + try: + node = btree.next() + if not node.key.startswith(rkey): + break + except NoNeighbourPageError: + break + + chunks.append(node.data) + + chunk_offset = struct.unpack(">I", node.key[-4:])[0] + chunk_offsets.append(chunk_offset) + + chunk_offsets.append(size) + + buf = [] + chunk_offset = 0 + for chunk, next_chunk_offset in zip(chunks, chunk_offsets[1:], strict=False): + # Chunk sizes should be used to determine if a chunk is compressed + if len(chunk) != next_chunk_offset - chunk_offset: + chunk = compression.decompress(chunk) + buf.append(chunk) + chunk_offset += next_chunk_offset + + return b"".join(buf) + + def _add_column(self, column: Column) -> None: + """Add a column to the table.""" + self.columns.append(column) + self._column_name_map[column.name] = column + self._column_id_map[column.identifier] = column + + # Precalculate fixed value offsets + if column.identifier < 128: + column._offset = self._fixed_value_offset + self._fixed_value_offset += column.size + + def _add_index(self, index: Index) -> None: + """Add an index to the table.""" + self.indexes.append(index) + self._index_name_map[index.name] = index + + +class Column: + def __init__(self, identifier: int, name: str, type_: JET_coltyp, record: Record | None = None): + self.identifier = identifier + self.name = name + self.type = type_ + + # Set by the table when added, only relevant for fixed value columns + self._offset = None + + self.record = record + + def __repr__(self) -> str: + return f"" + + @property + def offset(self) -> int: + return self._offset + + @cached_property + def is_fixed(self) -> bool: + return self.identifier <= 127 + + @cached_property + def is_variable(self) -> bool: + return 127 < self.identifier <= 255 + + @cached_property + def is_tagged(self) -> bool: + return self.identifier > 255 + + @cached_property + def is_text(self) -> bool: + return self.type in (JET_coltyp.Text, JET_coltyp.LongText) + + @cached_property + def is_binary(self) -> bool: + return self.type in (JET_coltyp.Binary, JET_coltyp.LongBinary) + + @cached_property + def size(self) -> int: + if self.record and self.record.get("SpaceUsage"): + return self.record.get("SpaceUsage") + return self.ctype.size + + @cached_property + def default(self) -> Any | None: + if self.record and self.record.get("DefaultValue"): + return self.record.get("DefaultValue") + return None + + @cached_property + def encoding(self) -> CODEPAGE | None: + if self.is_text: + return CODEPAGE(self.record.get("PagesOrLocale")) if self.record else CODEPAGE.ASCII + return None + + @cached_property + def ctype(self) -> ColumnType: + return COLUMN_TYPE_MAP[self.type.value] + + +class Catalog: + """Parse and interact with the catalog table. + + The catalog is a special table that contains the metadata for all the other tables in the database. + + Args: + db: An instance of :class:`~dissect.database.ese.ese.ESE`. + root_page: The root page of the catalog table. + """ + + CATALOG_COLUMNS = ( + Column(1, "ObjidTable", JET_coltyp.Long), + Column(2, "Type", JET_coltyp.Short), + Column(3, "Id", JET_coltyp.Long), + Column(4, "ColtypOrPgnoFDP", JET_coltyp.Long), + Column(5, "SpaceUsage", JET_coltyp.Long), + Column(6, "Flags", JET_coltyp.Long), + Column(7, "PagesOrLocale", JET_coltyp.Long), + Column(8, "RootFlag", JET_coltyp.Bit), + Column(9, "RecordOffset", JET_coltyp.Short), + Column(10, "LCMapFlags", JET_coltyp.Long), + Column(11, "KeyMost", JET_coltyp.UnsignedShort), + Column(12, "LVChunkMax", JET_coltyp.Long), + Column(128, "Name", JET_coltyp.Text), + Column(129, "Stats", JET_coltyp.Binary), + Column(130, "TemplateTable", JET_coltyp.Text), + Column(131, "DefaultValue", JET_coltyp.Binary), + Column(132, "KeyFldIDs", JET_coltyp.Binary), + Column(133, "VarSegMac", JET_coltyp.Binary), + Column(134, "ConditionalColumns", JET_coltyp.Binary), + Column(135, "TupleLimits", JET_coltyp.Binary), + Column(136, "Version", JET_coltyp.Binary), + Column(137, "SortID", JET_coltyp.Binary), + Column(256, "CallbackData", JET_coltyp.LongBinary), + Column(257, "CallbackDependencies", JET_coltyp.LongBinary), + Column(258, "SeparateLV", JET_coltyp.LongBinary), + Column(259, "SpaceHints", JET_coltyp.LongBinary), + Column(260, "SpaceDeferredLVHints", JET_coltyp.LongBinary), + Column(261, "LocaleName", JET_coltyp.LongBinary), + ) + + def __init__(self, db: ESE, root_page: Page): + self.db = db + self.root_page = root_page + self.tables = [] + self._table_name_map = {} + + # Create a dummy table with a preset list of columns + self._ctable = Table(db, None, root_page, columns=self.CATALOG_COLUMNS) + + cur_table = None + for rec in self._ctable.records(): + rtype = rec.get("Type") + if rtype == SYSOBJ.Table: + cur_table = Table(self.db, rec.get("Name"), rec.get("ColtypOrPgnoFDP"), record=rec) + self.tables.append(cur_table) + self._table_name_map[rec.get("Name")] = cur_table + + elif rtype == SYSOBJ.Column: + column = Column(rec.get("Id"), rec.get("Name"), JET_coltyp(rec.get("ColtypOrPgnoFDP")), record=rec) + cur_table._add_column(column) + + elif rtype == SYSOBJ.Index: + index = Index(cur_table, record=rec) + cur_table._add_index(index) + + elif rtype == SYSOBJ.LongValue: + cur_table._long_value_record = rec + + elif rtype == SYSOBJ.Callback: + cur_table._long_callback_record = rec + + def table(self, name: str) -> Table: + """Retrieve the table with the given name. + + Args: + name: The table to retrieve. + + Raises: + KeyError: If no table with that name exists. + """ + try: + return self._table_name_map[name] + except KeyError: + raise KeyError(f"No table with name: {name}") diff --git a/dissect/database/ese/tools/__init__.py b/dissect/database/ese/tools/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/dissect/database/ese/tools/impacket.py b/dissect/database/ese/tools/impacket.py new file mode 100644 index 0000000..a1181b4 --- /dev/null +++ b/dissect/database/ese/tools/impacket.py @@ -0,0 +1,72 @@ +from __future__ import annotations + +import runpy +import sys +from pathlib import Path +from typing import TYPE_CHECKING, Any + +from dissect.database.ese import ESE + +if TYPE_CHECKING: + from collections.abc import Iterator + + from dissect.database.ese.record import Record + from dissect.database.ese.util import RecordValue + +try: + from impacket import ese +except ImportError: + print("This utility monkeypatches ESENT_DB from impacket, but impacket is not installed", file=sys.stderr) + exit(1) + + +class ESENT_DB: + def __init__(self, fileName: Any, pageSize: int = 8192, isRemote: bool = False) -> None: + # I don't know what ``isRemote`` actually does so mimick what Impacket does + if isRemote: + self.fh = fileName + self.fh.open() + else: + self.fh = Path(fileName).open("rb") # noqa: SIM115 + self.db = ESE(self.fh, impacket_compat=True) + + def openTable(self, tableName: str) -> Iterator[Record]: + # Impacket only ever asks for the "next" record, so our cursor can simply be the record iterator + return self.db.table(tableName).records() + + def getNextRow(self, cursor: Iterator[Record], filter_tables: list[str] | None = None) -> RecordWrapper | None: + # Impacket uses a list to filter column names to make parsing a bit more efficient, but our parsing already + # skips columns you don't request the value for + try: + # Impacket treats column names as bytes so we need to wrap all records to translate column lookup + return RecordWrapper(next(cursor)) + except StopIteration: + return None + + def close(self) -> None: + self.fh.close() + + +class RecordWrapper: + def __init__(self, record: Record): + self._record = record + + def __getitem__(self, attr: bytes) -> RecordValue: + # Impacket treats column names as bytes so decode to string + return self._record.get(attr.decode()) + + +ese.ESENT_DB = ESENT_DB + + +if __name__ == "__main__": + if len(sys.argv) == 1: + print( + "Usage: python -m dissect.database.ese.tools.impacket /path/to/impacket/secretsdump.py ", + file=sys.stderr, + ) + exit(1) + + del sys.argv[0] + main_globals = sys.modules["__main__"].__dict__ + runpy.run_path(sys.argv[0], main_globals, "__main__") diff --git a/dissect/database/ese/tools/sru.py b/dissect/database/ese/tools/sru.py new file mode 100644 index 0000000..049612e --- /dev/null +++ b/dissect/database/ese/tools/sru.py @@ -0,0 +1,173 @@ +from __future__ import annotations + +import argparse +from pathlib import Path +from typing import TYPE_CHECKING, BinaryIO + +from dissect.util.sid import read_sid +from dissect.util.ts import oatimestamp, wintimestamp + +from dissect.database.ese.ese import ESE +from dissect.database.ese.record import Record, serialise_record_column_values + +if TYPE_CHECKING: + from collections.abc import Iterator + + from dissect.database.ese.table import Table + from dissect.database.ese.util import RecordValue + +NATIVE_TYPE_MAP = { + "{DD6636C4-8929-4683-974E-22C046A43763}": {"ConnectStartTime": wintimestamp}, + "{5C8CF1C7-7257-4F13-B223-970EF5939312}": {"EndTime": wintimestamp}, +} + +SKIP_TABLES = [ + "MSysObjects", + "MSysObjectsShadow", + "MSysObjids", + "MSysLocales", + "SruDbIdMapTable", + "SruDbCheckpointTable", +] + + +NAME_TO_GUID_MAP = { + "network_data": "{973F5D5C-1D90-4944-BE8E-24B94231A174}", + "network_connectivity": "{DD6636C4-8929-4683-974E-22C046A43763}", + "energy_estimator": "{DA73FB89-2BEA-4DDC-86B8-6E048C6DA477}", + "energy_usage": "{FEE4E14F-02A9-4550-B5CE-5FA2DA202E37}", + "energy_usage_lt": "{FEE4E14F-02A9-4550-B5CE-5FA2DA202E37}LT", + "application": "{D10CA2FE-6FCF-4F6D-848E-B2E99266FA89}", + "push_notifications": "{D10CA2FE-6FCF-4F6D-848E-B2E99266FA86}", + "application_timeline": "{5C8CF1C7-7257-4F13-B223-970EF5939312}", + "vfu": "{7ACBBAA3-D029-4BE4-9A7A-0885927F1D8F}", + # Refs: + # - http://dfir.pro/index.php?link_id=92259 and + # - HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\SRUM\Extensions + "sdp_volume_provider": "{17F4D97B-F26A-5E79-3A82-90040A47D13D}", + "sdp_physical_disk_provider": "{841A7317-3805-518B-C2EA-AD224CB4AF84}", + "sdp_cpu_provider": "{DC3D3B50-BB90-5066-FA4E-A5F90DD8B677}", + "sdp_network_provider": "{EEE2F477-0659-5C47-EF03-6D6BEFD441B3}", + # not seen in the wild + "sdp_perf_count_provider": "{38AD6548-9313-58F8-45C7-D293BAFDC879}", + "sdp_event_log_provider": "{CDF8EBF6-7C0F-5AC2-158F-DBFBEE981152}", +} + + +class SRU: + def __init__(self, fh: BinaryIO): + self.db = ESE(fh) + + id_map_table = self.db.table("SruDbIdMapTable") + self.id_map = {r.get("IdIndex"): r for r in id_map_table.records()} + + def get_table(self, table_name: str | None = None, table_guid: str | None = None) -> Table | None: + if all((table_name, table_guid)) or not any((table_name, table_guid)): + raise ValueError("Either table_name or table_guid must be provided") + + if table_name and table_name not in NAME_TO_GUID_MAP: + raise ValueError(f"Unknown table name: {table_name}") + + table_guid = table_guid or NAME_TO_GUID_MAP[table_name] + + try: + return self.db.table(table_guid) + except KeyError: + return None + + def entries(self) -> Iterator[Entry]: + for t in self.db.tables(): + if t.name in SKIP_TABLES: + continue + yield from self.get_table_entries(table=t) + + __iter__ = entries + + def get_table_entries( + self, table: Table = None, table_name: str | None = None, table_guid: str | None = None + ) -> Iterator[Entry]: + table = table or self.get_table(table_name=table_name, table_guid=table_guid) + if not table: + return + for record in table.records(): + yield Entry(self, table, record) + + def resolve_id(self, value: int) -> str | None: + try: + record = self.id_map[value] + except KeyError: + raise IndexError(value) + + if not record.get("IdBlob"): + return None + + if record.get("IdType") in (0, 1, 2): + return record.get("IdBlob").decode("utf-16-le").rstrip("\x00") + return read_sid(record.get("IdBlob")) + + +class Entry: + def __init__(self, sru: SRU, table: Table, record: Record): + self.sru = sru + self.table = table + self.record = record + self.provider = table.name + + def _get(self, attr: str) -> RecordValue: + value = self.record.get(attr) + if value is None: + return value + + if attr in ("AppId", "UserId"): + value = self.sru.resolve_id(value) + + if attr == "TimeStamp": + value = oatimestamp(value) + + type_map = NATIVE_TYPE_MAP.get(self.table.name, None) + if type_map and attr in type_map: + value = type_map[attr](value) + + # Application timeline ({5C8CF1C7-7257-4F13-B223-970EF5939312}) seems to have a weird null value + # (******** in decimal) + if self.table.name == "{5C8CF1C7-7257-4F13-B223-970EF5939312}" and value in (0x2A2A2A2A2A2A2A2A, 0x2A2A2A2A): + value = None + + return value + + def __getitem__(self, attr: str) -> RecordValue: + return self._get(attr) + + def __getattr__(self, attr: str) -> RecordValue: + try: + return self._get(attr) + except Exception: + return object.__getattribute__(self, attr) + + def __repr__(self) -> str: + column_values = serialise_record_column_values(self.record) + return f"" + + +def main() -> None: + parser = argparse.ArgumentParser(description="dissect.database.ese SRU parser") + parser.add_argument("input", help="SRU database to read") + parser.add_argument("-p", "--provider", help="filter records from this provider") + args = parser.parse_args() + + with Path(args.input).open("rb") as fh: + parser = SRU(fh) + + if args.provider in NAME_TO_GUID_MAP: + for e in parser.get_table_entries(table_name=args.provider): + print(e) + elif args.provider: + for e in parser.get_table_entries(table_guid=args.provider): + print(e) + else: + for e in parser.entries(): + print(e) + + +if __name__ == "__main__": + main() diff --git a/dissect/database/ese/tools/ual.py b/dissect/database/ese/tools/ual.py new file mode 100644 index 0000000..9cec70f --- /dev/null +++ b/dissect/database/ese/tools/ual.py @@ -0,0 +1,107 @@ +import argparse +import datetime +import ipaddress +from collections.abc import Iterator +from pathlib import Path +from typing import BinaryIO + +from dissect.util.ts import wintimestamp + +from dissect.database.ese.ese import ESE +from dissect.database.ese.table import Table +from dissect.database.ese.util import RecordValue + +UalValue = RecordValue | ipaddress.IPv4Address | ipaddress.IPv6Interface | tuple[datetime.datetime] + +SKIP_TABLES = [ + "MSysObjects", + "MSysObjectsShadow", + "MSysObjids", + "MSysLocales", +] + + +class UAL: + WIN_DATETIME_FIELDS = ( + "CreationTime", + "FirstSeen", + "InsertDate", + "LastAccess", + "LastSeen", + ) + + def __init__(self, fh: BinaryIO): + self.db = ESE(fh) + + def get_tables(self) -> list[Table]: + return self.db.tables() + + def get_table_records(self, table_name: str) -> Iterator[dict[str, UalValue]]: + try: + table = self.db.table(table_name) + except KeyError: + return None + + for record in table.records(): + record_data = {} + + last_access_year = None + day_counts = {} + + for column in table.columns: + value = record.get(column.name) + + if column.name in self.WIN_DATETIME_FIELDS: + value = wintimestamp(value) + + if column.name == "LastAccess": + last_access_year = value.year + + if column.name == "Address" and isinstance(value, bytes): + value = ipaddress.ip_address(value) + value = str(value) + + if column.name.startswith("Day"): + day_num = int(column.name[3:]) + day_counts[day_num] = value + continue + + record_data[column.name] = value + + if day_counts: + if last_access_year: + # drop days without counts and convert day number to date + day_counts = { + convert_day_num_to_date(last_access_year, day_num): count + for day_num, count in day_counts.items() + if count + } + else: + day_counts = {} + record_data["activity_counts"] = tuple(day_counts.items()) + + yield record_data + + +def convert_day_num_to_date(year: int, day_num: int) -> datetime.datetime: + return datetime.datetime(year, 1, 1, tzinfo=datetime.timezone.utc) + datetime.timedelta(day_num - 1) + + +def main() -> None: + parser = argparse.ArgumentParser(description="dissect.database.ese UAL parser") + parser.add_argument("input", help="UAL database to read") + args = parser.parse_args() + + with Path(args.input).open("rb") as fh: + parser = UAL(fh) + + for table in parser.get_tables(): + if table.name in SKIP_TABLES: + continue + + for record in parser.get_table_records(table.name): + print(record) + + +if __name__ == "__main__": + main() diff --git a/dissect/database/ese/util.py b/dissect/database/ese/util.py new file mode 100644 index 0000000..42d8746 --- /dev/null +++ b/dissect/database/ese/util.py @@ -0,0 +1,93 @@ +from __future__ import annotations + +import datetime +import struct +from typing import TYPE_CHECKING, Any, NamedTuple, TypeAlias +from uuid import UUID + +from dissect.database.ese.c_ese import CODEPAGE, JET_coltyp, c_ese + +if TYPE_CHECKING: + from collections.abc import Callable + +CODEPAGE_MAP = { + CODEPAGE.UNICODE: "utf-16-le", + CODEPAGE.WESTERN: "cp1252", + CODEPAGE.ASCII: "ascii", +} + + +RecordValue: TypeAlias = int | float | str | bytes | datetime.datetime | None + + +def decode_bit(buf: bytes) -> bool: + """Decode a bit into a boolean. + + Args: + buf: The buffer to decode from. + """ + return c_ese.uint8(buf) == 0xFF + + +def decode_text(buf: bytes, encoding: CODEPAGE, errors: str | None = "backslashreplace") -> str: + """Decode text with the appropriate encoding. + + Args: + buf: The buffer to decode from. + """ + buf = bytes(buf) + + if encoding == CODEPAGE.UNICODE and len(buf) % 2: + buf += b"\x00" + + return buf.decode(CODEPAGE_MAP[encoding], errors=errors).rstrip("\x00") + + +def decode_guid(buf: bytes) -> str: + """Decode a GUID. + + Args: + buf: The buffer to decode from. + """ + return str(UUID(bytes_le=bytes(buf))) + + +def checksum_xor(data: bytes, initial: int = 0x89ABCDEF) -> int: + digest = initial + for val in struct.unpack(f"<{len(data) // 4}I", data): + digest ^= val + + return digest + + +class ColumnType(NamedTuple): + value: JET_coltyp + name: str + size: int | None + parse: Callable[[bytes], Any] | None + + +COLUMN_TYPES = [ + ColumnType(JET_coltyp.Nil, "NULL", 0, None), + ColumnType(JET_coltyp.Bit, "Boolean", 1, decode_bit), + ColumnType(JET_coltyp.UnsignedByte, "Unsigned byte", 1, c_ese.uint8), + ColumnType(JET_coltyp.Short, "Signed short", 2, c_ese.int16), + ColumnType(JET_coltyp.Long, "Signed long", 4, c_ese.int32), + ColumnType(JET_coltyp.Currency, "Currency", 8, c_ese.int64), + ColumnType(JET_coltyp.IEEESingle, "Single precision FP", 4, c_ese.float), + ColumnType(JET_coltyp.IEEEDouble, "Double precision FP", 8, c_ese.double), + # Parse DateTime as an int64 because the actual parsing of the value can differ between databases + # E.g. by default it's supposed to be an OA date, but the UAL stores it as a regular Windows timestamp + ColumnType(JET_coltyp.DateTime, "DateTime", 8, c_ese.int64), + ColumnType(JET_coltyp.Binary, "Binary", None, bytes), + ColumnType(JET_coltyp.Text, "Text", None, decode_text), + ColumnType(JET_coltyp.LongBinary, "Long Binary", None, bytes), + ColumnType(JET_coltyp.LongText, "Long Text", None, decode_text), + ColumnType(JET_coltyp.SLV, "Super Long Value", None, None), + ColumnType(JET_coltyp.UnsignedLong, "Unsigned long", 4, c_ese.uint32), + ColumnType(JET_coltyp.LongLong, "Signed Long long", 8, c_ese.int64), + ColumnType(JET_coltyp.GUID, "GUID", 16, decode_guid), + ColumnType(JET_coltyp.UnsignedShort, "Unsigned short", 2, c_ese.uint16), + ColumnType(JET_coltyp.Max, "Max", None, None), +] +COLUMN_TYPE_MAP = {t.value.value: t for t in COLUMN_TYPES} diff --git a/pyproject.toml b/pyproject.toml index 1dea17f..825c79a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "dissect.database" -description = "A Dissect module implementing parsers for various database formats, including Berkeley DB and SQLite3" +description = "A Dissect module implementing parsers for various database formats, including Berkeley DB, Microsofts Extensible Storage Engine (ESE) and SQLite3" readme = "README.md" requires-python = ">=3.10" license = "Apache-2.0" @@ -26,6 +26,7 @@ classifiers = [ ] dependencies = [ "dissect.cstruct>=4,<5", + "dissect.util>=3.5,<4", ] dynamic = ["version"] diff --git a/tests/_data/ese/Windows.edb.gz b/tests/_data/ese/Windows.edb.gz new file mode 100644 index 0000000..116e20a --- /dev/null +++ b/tests/_data/ese/Windows.edb.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ecf10e05bf95c43ae7112e071d085d8c2e6fcc8d730b4088e10f9a26f7c76212 +size 6989125 diff --git a/tests/_data/ese/basic.edb.gz b/tests/_data/ese/basic.edb.gz new file mode 100755 index 0000000..0d937eb --- /dev/null +++ b/tests/_data/ese/basic.edb.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d1bab7fca049256efa662b0563d40c8e59b7828413412d1d2d745a49e53be395 +size 9771 diff --git a/tests/_data/ese/binary.edb.gz b/tests/_data/ese/binary.edb.gz new file mode 100755 index 0000000..66b0ee4 --- /dev/null +++ b/tests/_data/ese/binary.edb.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f6340c61b540df1c35b3c094759073c1ffaf438612cb22e000bbaac43bfc12fb +size 9913 diff --git a/tests/_data/ese/default.edb.gz b/tests/_data/ese/default.edb.gz new file mode 100755 index 0000000..a825fd9 --- /dev/null +++ b/tests/_data/ese/default.edb.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5e01cfc86d5a6b21d7730cd075e38e56fbef338f73ef28269a6ae69833e3f454 +size 10431 diff --git a/tests/_data/ese/index.edb.gz b/tests/_data/ese/index.edb.gz new file mode 100755 index 0000000..5952467 --- /dev/null +++ b/tests/_data/ese/index.edb.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:58576e28dcfddbfde003c2a6dc5b36df5f61751a0c8d14b4ce9c2876f5554074 +size 12993 diff --git a/tests/_data/ese/large.edb.gz b/tests/_data/ese/large.edb.gz new file mode 100755 index 0000000..a368f75 --- /dev/null +++ b/tests/_data/ese/large.edb.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ac45242653a3f5d01259cba88c828cb77142713ac3c3be71e57b7973abcc4113 +size 2009304 diff --git a/tests/_data/ese/multi.edb.gz b/tests/_data/ese/multi.edb.gz new file mode 100755 index 0000000..77a205f --- /dev/null +++ b/tests/_data/ese/multi.edb.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:71542cae42e887b6f919a7728b1dd0e729174bad461e87d4ae3da15b5bf78e2f +size 12291 diff --git a/tests/_data/ese/text.edb.gz b/tests/_data/ese/text.edb.gz new file mode 100755 index 0000000..8bed30e --- /dev/null +++ b/tests/_data/ese/text.edb.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:710bb228ebe590a37aba5a1e4508079f085ac365d66ec4a4cafd2e448c816a82 +size 11790 diff --git a/tests/_data/ese/tools/Current.mdb.gz b/tests/_data/ese/tools/Current.mdb.gz new file mode 100644 index 0000000..57d849c --- /dev/null +++ b/tests/_data/ese/tools/Current.mdb.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d13264e52650ea352ab2f88e5c9868cf9978ad6607ceba98c3f44a53bed07ca9 +size 56705 diff --git a/tests/_data/ese/tools/SRUDB.dat.gz b/tests/_data/ese/tools/SRUDB.dat.gz new file mode 100644 index 0000000..0036e5f --- /dev/null +++ b/tests/_data/ese/tools/SRUDB.dat.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bf3a5ce9f2b738a3302c050360ec0277897ccc5f8cda32d9afd843e47183c7cf +size 52655 diff --git a/tests/ese/__init__.py b/tests/ese/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/ese/conftest.py b/tests/ese/conftest.py new file mode 100644 index 0000000..ebe8d03 --- /dev/null +++ b/tests/ese/conftest.py @@ -0,0 +1,60 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, BinaryIO + +import pytest + +from tests._util import open_file_gz + +if TYPE_CHECKING: + from collections.abc import Iterator + + +@pytest.fixture +def basic_db() -> Iterator[BinaryIO]: + yield from open_file_gz("_data/ese/basic.edb.gz") + + +@pytest.fixture +def binary_db() -> Iterator[BinaryIO]: + yield from open_file_gz("_data/ese/binary.edb.gz") + + +@pytest.fixture +def text_db() -> Iterator[BinaryIO]: + yield from open_file_gz("_data/ese/text.edb.gz") + + +@pytest.fixture +def multi_db() -> Iterator[BinaryIO]: + yield from open_file_gz("_data/ese/multi.edb.gz") + + +@pytest.fixture +def default_db() -> Iterator[BinaryIO]: + yield from open_file_gz("_data/ese/default.edb.gz") + + +@pytest.fixture +def index_db() -> Iterator[BinaryIO]: + yield from open_file_gz("_data/ese/index.edb.gz") + + +@pytest.fixture +def large_db() -> Iterator[BinaryIO]: + yield from open_file_gz("_data/ese/large.edb.gz") + + +@pytest.fixture +def windows_search_db() -> Iterator[BinaryIO]: + yield from open_file_gz("_data/ese/Windows.edb.gz") + + +@pytest.fixture +def sru_db() -> Iterator[BinaryIO]: + yield from open_file_gz("_data/ese/tools/SRUDB.dat.gz") + + +@pytest.fixture +def ual_db() -> Iterator[BinaryIO]: + yield from open_file_gz("_data/ese/tools/Current.mdb.gz") diff --git a/tests/ese/test_cursor.py b/tests/ese/test_cursor.py new file mode 100644 index 0000000..9d19f8c --- /dev/null +++ b/tests/ese/test_cursor.py @@ -0,0 +1,59 @@ +from typing import BinaryIO + +from dissect.database.ese.ese import ESE + + +def test_cursor(basic_db: BinaryIO) -> None: + db = ESE(basic_db) + table = db.table("basic") + idx = table.index("IxId") + + cursor = idx.cursor() + record = cursor.search(Id=1) + assert record.Id == 1 + record = cursor.next() + assert record.Id == 2 + record = cursor.prev() + assert record.Id == 1 + assert record.Id == cursor.record().Id + + +def test_cursor_iterator(basic_db: BinaryIO) -> None: + db = ESE(basic_db) + table = db.table("basic") + idx = table.index("IxId") + + cursor = idx.cursor() + records = list(cursor) + assert len(records) == 2 + assert records[0].Id == 1 + assert records[1].Id == 2 + + +def test_cursor_search(ual_db: BinaryIO) -> None: + db = ESE(ual_db) + table = db.table("CLIENTS") + idx = table.index("Username_RoleGuid_TenantId_index") + + cursor = idx.cursor() + records = list( + cursor.find_all( + AuthenticatedUserName="blackclover\\administrator", + RoleGuid="ad495fc3-0eaa-413d-ba7d-8b13fa7ec598", + TenantId="2417e4c3-5467-40c5-809b-12b59a86c102", + ) + ) + + assert len(records) == 5 + + cursor.reset() + records = list( + cursor.find_all( + AuthenticatedUserName="blackclover\\administrator", + RoleGuid="ad495fc3-0eaa-413d-ba7d-8b13fa7ec598", + TenantId="2417e4c3-5467-40c5-809b-12b59a86c102", + Day204=4, + ) + ) + + assert len(records) == 1 diff --git a/tests/ese/test_ese.py b/tests/ese/test_ese.py new file mode 100644 index 0000000..fc384e2 --- /dev/null +++ b/tests/ese/test_ese.py @@ -0,0 +1,355 @@ +from __future__ import annotations + +import datetime +from typing import BinaryIO + +from dissect.util.ts import oatimestamp + +from dissect.database.ese.c_ese import JET_coltyp +from dissect.database.ese.ese import ESE + + +def test_basic_types(basic_db: BinaryIO) -> None: + db = ESE(basic_db) + table = db.table("basic") + + assert [(col.name, col.type) for col in table.columns] == [ + ("Id", JET_coltyp.Long), + ("Bit", JET_coltyp.Bit), + ("UnsignedByte", JET_coltyp.UnsignedByte), + ("Short", JET_coltyp.Short), + ("Long", JET_coltyp.Long), + ("Currency", JET_coltyp.Currency), + ("IEEESingle", JET_coltyp.IEEESingle), + ("IEEEDouble", JET_coltyp.IEEEDouble), + ("DateTime", JET_coltyp.DateTime), + ("UnsignedLong", JET_coltyp.UnsignedLong), + ("LongLong", JET_coltyp.LongLong), + ("GUID", JET_coltyp.GUID), + ("UnsignedShort", JET_coltyp.UnsignedShort), + ] + + records = list(table.records()) + assert len(records) == 2 + + assert records[0].Id == 1 + assert records[0].Bit is False + assert records[0].UnsignedByte == 213 + assert records[0].Short == -1337 + assert records[0].Long == -13371337 + assert records[0].Currency == 1337133713371337 + assert records[0].IEEESingle == 1.0 + assert records[0].IEEEDouble == 13371337.13371337 + assert oatimestamp(records[0].DateTime) == datetime.datetime(1999, 3, 1, 0, 0, tzinfo=datetime.timezone.utc) + assert records[0].UnsignedLong == 13371337 + assert records[0].LongLong == -13371337 + assert records[0].GUID == "3f360af1-6766-46dc-9af2-0dacf295c2a1" + assert records[0].UnsignedShort == 1337 + + assert records[1].Id == 2 + assert records[1].Bit is True + assert records[1].UnsignedByte == 255 + assert records[1].Short == 1339 + assert records[1].Long == 13391339 + assert records[1].Currency == -1339133913391339 + assert records[1].IEEESingle == -2.0 + assert records[1].IEEEDouble == -13391339.13391339 + assert oatimestamp(records[1].DateTime) == datetime.datetime(1337, 6, 9, 0, 0, tzinfo=datetime.timezone.utc) + + +def test_binary_types(binary_db: BinaryIO) -> None: + db = ESE(binary_db) + table = db.table("binary") + + assert [(col.name, col.type) for col in table.columns] == [ + ("Id", JET_coltyp.Long), + ("FixedBinary", JET_coltyp.Binary), + ("NullableFixedBinary", JET_coltyp.Binary), + ("Binary", JET_coltyp.Binary), + ("NullableBinary", JET_coltyp.Binary), + ("MaxBinary", JET_coltyp.Binary), + ("TaggedBinary", JET_coltyp.Binary), + ("NullableTaggedBinary", JET_coltyp.Binary), + ("LongBinary", JET_coltyp.LongBinary), + ("LongCompressedBinary", JET_coltyp.LongBinary), + ("MaxLongBinary", JET_coltyp.LongBinary), + ("MaxLongCompressedBinary", JET_coltyp.LongBinary), + ] + + records = list(table.records()) + assert len(records) == 1 + + assert records[0].Id == 1 + assert records[0].FixedBinary == b"test fixed binary data" + (b"\x00" * 233) + assert records[0].NullableFixedBinary is None + assert records[0].Binary == b"test binary data" + assert records[0].NullableBinary is None + assert records[0].MaxBinary == b"test max binary data " + (b"a" * 70) + assert records[0].TaggedBinary == b"test tagged binary data" + assert records[0].NullableTaggedBinary is None + assert records[0].LongBinary == b"test long binary data " + (b"a" * 1000) + assert records[0].LongCompressedBinary == b"test long compressed binary data " + (b"a" * 1000) + assert records[0].MaxLongBinary == b"test max long binary data " + (b"a" * 900) + assert records[0].MaxLongCompressedBinary == b"test max long compressed binary data " + (b"a" * 900) + + +def test_text_types(text_db: BinaryIO) -> None: + db = ESE(text_db) + table = db.table("text") + + assert [(col.name, col.type) for col in table.columns] == [ + ("Id", JET_coltyp.Long), + ("FixedASCII", JET_coltyp.Text), + ("FixedUnicode", JET_coltyp.Text), + ("NullableFixedASCII", JET_coltyp.Text), + ("NullableFixedUnicode", JET_coltyp.Text), + ("ASCII", JET_coltyp.Text), + ("Unicode", JET_coltyp.Text), + ("NullableASCII", JET_coltyp.Text), + ("NullableUnicode", JET_coltyp.Text), + ("MaxASCII", JET_coltyp.Text), + ("MaxUnicode", JET_coltyp.Text), + ("TaggedASCII", JET_coltyp.Text), + ("TaggedUnicode", JET_coltyp.Text), + ("NullableTaggedASCII", JET_coltyp.Text), + ("NullableTaggedUnicode", JET_coltyp.Text), + ("LongASCII", JET_coltyp.LongText), + ("LongUnicode", JET_coltyp.LongText), + ("LongCompressedASCII", JET_coltyp.LongText), + ("LongCompressedUnicode", JET_coltyp.LongText), + ("LongTinyASCII", JET_coltyp.LongText), + ("LongTinyUnicode", JET_coltyp.LongText), + ("LongTinyCompressedASCII", JET_coltyp.LongText), + ("LongTinyCompressedUnicode", JET_coltyp.LongText), + ("MaxLongASCII", JET_coltyp.LongText), + ("MaxLongUnicode", JET_coltyp.LongText), + ("MaxLongCompressedASCII", JET_coltyp.LongText), + ("MaxLongCompressedUnicode", JET_coltyp.LongText), + ] + + records = list(table.records()) + assert len(records) == 1 + + assert records[0].Id == 1 + assert records[0].FixedASCII == "Fixed ASCII text" + (" " * 239) + assert records[0].FixedUnicode == "Fixed Unicode text 🦊" + (" " * 107) + assert records[0].NullableFixedASCII is None + assert records[0].NullableFixedUnicode is None + assert records[0].ASCII == "Simple ASCII text" + assert records[0].Unicode == "Simple Unicode text 🦊" + assert records[0].NullableASCII is None + assert records[0].NullableUnicode is None + assert records[0].MaxASCII == "Max ASCII text that can't be that long" + assert records[0].MaxUnicode == "Max Unicode text that can't be that long 🦊" + assert records[0].TaggedASCII == "Tagged ASCII text" + assert records[0].TaggedUnicode == "Tagged Unicode text 🦊" + assert records[0].NullableTaggedASCII is None + assert records[0].NullableTaggedUnicode is None + assert records[0].LongASCII == "Long ASCII text " + ("a" * 1024) + assert records[0].LongUnicode == "Long Unicode text 🦊 " + ("a" * 1024) + assert records[0].LongCompressedASCII == "Long compressed ASCII text " + ("a" * 1024) + assert records[0].LongCompressedUnicode == "Long compressed Unicode text 🦊 " + ("a" * 1024) + assert records[0].LongTinyASCII == "Tiny ASCII" + assert records[0].LongTinyUnicode == "Tiny 🦊" + assert records[0].LongTinyCompressedASCII == "Tiny c ASCII" + assert records[0].LongTinyCompressedUnicode == "Tiny c 🦊" + assert records[0].MaxLongASCII == "Max long ASCII text that can be a bit longer " + ("a" * 900) + assert records[0].MaxLongUnicode == "Max long Unicode text that can be a bit longer 🦊 " + ("a" * 900) + assert records[0].MaxLongCompressedASCII == "Max long compressed ASCII text that can be a bit longer " + ("a" * 900) + assert records[0].MaxLongCompressedUnicode == "Max long compressed Unicode text that can be a bit longer 🦊 " + ( + "a" * 900 + ) + + +def test_multivalue_types(multi_db: BinaryIO) -> None: + db = ESE(multi_db) + table = db.table("multi") + + assert [(col.name, col.type) for col in table.columns] == [ + ("Id", JET_coltyp.Long), + ("Bit", JET_coltyp.Bit), + ("UnsignedByte", JET_coltyp.UnsignedByte), + ("Short", JET_coltyp.Short), + ("Long", JET_coltyp.Long), + ("Currency", JET_coltyp.Currency), + ("IEEESingle", JET_coltyp.IEEESingle), + ("IEEEDouble", JET_coltyp.IEEEDouble), + ("DateTime", JET_coltyp.DateTime), + ("Binary", JET_coltyp.Binary), + ("LongBinary", JET_coltyp.LongBinary), + ("LongCompressedBinary", JET_coltyp.LongBinary), + ("ASCII", JET_coltyp.Text), + ("Unicode", JET_coltyp.Text), + ("LongASCII", JET_coltyp.LongText), + ("LongUnicode", JET_coltyp.LongText), + ("LongCompressedASCII", JET_coltyp.LongText), + ("LongCompressedUnicode", JET_coltyp.LongText), + ("UnsignedLong", JET_coltyp.UnsignedLong), + ("LongLong", JET_coltyp.LongLong), + ("GUID", JET_coltyp.GUID), + ("UnsignedShort", JET_coltyp.UnsignedShort), + ] + + records = list(table.records()) + assert len(records) == 2 + + assert records[0].Id == 1 + assert records[0].Bit == [False, True] + assert records[0].UnsignedByte == [0, 127, 255] + assert records[0].Short == [0, -32767, 32767] + assert records[0].Long == [0, -2147483647, 2147483647] + assert records[0].Currency == [0, -9223372036854775807, 9223372036854775807] + assert records[0].IEEESingle == [0.0, -1.0, 1.0] + assert records[0].IEEEDouble == [0.0, -1.0, 1.0] + assert list(map(oatimestamp, records[0].DateTime)) == [ + datetime.datetime(1661, 4, 17, 11, 30, tzinfo=datetime.timezone.utc), + datetime.datetime(2077, 4, 1, 0, 0, tzinfo=datetime.timezone.utc), + datetime.datetime(2517, 9, 24, 5, 30, tzinfo=datetime.timezone.utc), + ] + assert records[0].Binary == [ + b"Some binary data that has multiple values, this is value 1", + b"Some binary data that has multiple values, this is value 2", + b"Some binary data that has multiple values, this is value 3", + ] + assert records[0].LongBinary == [ + b"Some very long binary data that has multiple values, this is value 1 " + (b"a" * 1024), + b"Some very long binary data that has multiple values, this is value 2 " + (b"a" * 1024), + b"Some very long binary data that has multiple values, this is value 3 " + (b"a" * 1024), + ] + assert records[0].LongCompressedBinary == [ + b"Some very long compressed binary data that has multiple values, this is value 1 " + (b"a" * 1024), + b"Some very long compressed binary data that has multiple values, this is value 2 " + (b"a" * 1024), + b"Some very long compressed binary data that has multiple values, this is value 3 " + (b"a" * 1024), + ] + assert records[0].ASCII == [ + "Some ASCII text that has multiple values, this is value 1", + "Some ASCII text that has multiple values, this is value 2", + "Some ASCII text that has multiple values, this is value 3", + ] + assert records[0].Unicode == [ + "Some Unicode text that has multiple values, this is value 1 🦊", + "Some Unicode text that has multiple values, this is value 2 🦊🦊", + "Some Unicode text that has multiple values, this is value 3 🦊🦊🦊", + ] + assert records[0].LongASCII == [ + "Some very long ASCII text that has multiple values, this is value 1 " + ("a" * 1024), + "Some very long ASCII text that has multiple values, this is value 2 " + ("a" * 1024), + "Some very long ASCII text that has multiple values, this is value 3 " + ("a" * 1024), + ] + assert records[0].LongUnicode == [ + "Some very long Unicode text that has multiple values, this is value 1 🦊 " + ("a" * 1024), + "Some very long Unicode text that has multiple values, this is value 2 🦊🦊 " + ("a" * 1024), + "Some very long Unicode text that has multiple values, this is value 3 🦊🦊🦊 " + ("a" * 1024), + ] + assert records[0].LongCompressedASCII == [ + "Some very long compressed ASCII text that has multiple values, this is value 1 " + ("a" * 1024), + "Some very long compressed ASCII text that has multiple values, this is value 2 " + ("a" * 1024), + "Some very long compressed ASCII text that has multiple values, this is value 3 " + ("a" * 1024), + ] + assert records[0].LongCompressedUnicode == [ + "Some very long compressed Unicode text that has multiple values, this is value 1 🦊 " + ("a" * 1024), + "Some very long compressed Unicode text that has multiple values, this is value 2 🦊🦊 " + ("a" * 1024), + "Some very long compressed Unicode text that has multiple values, this is value 3 🦊🦊🦊 " + ("a" * 1024), + ] + assert records[0].UnsignedLong == [0, 4294967295] + assert records[0].LongLong == [0, -9223372036854775807, 9223372036854775807] + assert records[0].GUID == [ + "03402861-fad3-4ce5-986e-d31df852f2a7", + "09b589e3-a92b-4936-bbc4-bb9dff334bf3", + "2212ff6a-6712-4fe4-bb4a-21e6d0e043d1", + ] + assert records[0].UnsignedShort == [0, 65535] + + # Test some small "long" multi-values and two-values + # Also test that the other columns should correctly be set to None + assert records[1].Id == 2 + assert records[1].Bit is None + assert records[1].UnsignedByte is None + assert records[1].Short is None + assert records[1].Long is None + assert records[1].Currency is None + assert records[1].IEEESingle is None + assert records[1].IEEEDouble is None + assert records[1].DateTime is None + assert records[1].Binary is None + assert records[1].LongBinary == [ + b"Tiny binary 1", + b"Tiny binary 2", + b"Tiny binary 3", + ] + assert records[1].LongCompressedBinary == [ + b"Tiny c binary 1", + b"Tiny c binary 2", + b"Tiny c binary 3", + ] + assert records[1].ASCII is None + assert records[1].Unicode is None + assert records[1].LongASCII == [ + "Tiny ASCII 1", + "Tiny ASCII 2", + ] + assert records[1].LongUnicode == [ + "Tiny 🦊 1", + "Tiny 🦊🦊", + "Tiny 🦊🦊🦊", + ] + assert records[1].LongCompressedASCII == [ + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "ccccccccccccccccccccccccccccccccccc", + ] + assert records[1].LongCompressedUnicode == [ + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 🦊", + "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb 🦊🦊", + ] + assert records[1].UnsignedLong is None + assert records[1].LongLong is None + assert records[1].GUID is None + assert records[1].UnsignedShort is None + + +def test_default_db(default_db: BinaryIO) -> None: + db = ESE(default_db) + table = db.table("default") + + records = list(table.records()) + assert len(records) == 1 + + assert records[0].Id == 1 + assert records[0].Bit is True + assert records[0].UnsignedByte == 69 + assert records[0].Short == 0x1234 + assert records[0].Long == 0x12345678 + assert records[0].Currency == 0x123456789ABCDEF0 + assert records[0].IEEESingle == 1.0 + assert records[0].IEEEDouble == 2.0 + assert oatimestamp(records[0].DateTime) == datetime.datetime(2022, 10, 4, 0, 0, tzinfo=datetime.timezone.utc) + assert records[0].UnsignedLong == 12345678 + assert records[0].LongLong == 0xC001DEADD00D + assert records[0].GUID == "c001d00d-dead-beef-face-feeddeadbeef" + assert records[0].UnsignedShort == 0xF00D + + assert records[0].Binary == b"Short default binary" + assert records[0].LongBinary == b"Long default binary " + (b"a" * 200) + assert records[0].ASCII == "Short default ASCII" + assert records[0].Unicode == "Short default Unicode 🦊" + assert records[0].LongASCII == "Long default ASCII " + ("a" * 200) + assert records[0].LongUnicode == "Long default Unicode 🦊 " + ("a" * 64) + + +def test_large_db(large_db: BinaryIO) -> None: + db = ESE(large_db) + table = db.table("large") + + assert db.page_size == 32 * 1024 + assert [(col.name, col.type) for col in table.columns] == [ + ("Id", JET_coltyp.Long), + ] + [(f"Column{i}", JET_coltyp.UnsignedShort) for i in range(64993)] + + assert len(list(db.pages())) == 766 + + records = list(table.records()) + assert len(records) == 16 + + for i in range(64993): + assert records[i // 4096].get(f"Column{i}") == i diff --git a/tests/ese/test_index.py b/tests/ese/test_index.py new file mode 100644 index 0000000..babd687 --- /dev/null +++ b/tests/ese/test_index.py @@ -0,0 +1,107 @@ +from __future__ import annotations + +from typing import BinaryIO + +from dissect.database.ese.ese import ESE + + +def test_index(index_db: BinaryIO) -> None: + db = ESE(index_db) + table = db.table("index") + + assert len(table.indexes) == 19 + + assert table.indexes[0].name == "IxId" + assert table.indexes[0].column_ids == [1] + record = table.indexes[0].search(Id=1) + assert record.Id == 1 + + assert table.indexes[1].name == "IxBit" + assert table.indexes[1].column_ids == [2] + record = table.indexes[1].search(Bit=False) + assert record.Bit is False + + assert table.indexes[2].name == "IxUnsignedByte" + assert table.indexes[2].column_ids == [3] + record = table.indexes[2].search(UnsignedByte=213) + assert record.UnsignedByte == 213 + + assert table.indexes[3].name == "IxShort" + assert table.indexes[3].column_ids == [4] + record = table.indexes[3].search(Short=-1337) + assert record.Short == -1337 + + assert table.indexes[4].name == "IxLong" + assert table.indexes[4].column_ids == [5] + record = table.indexes[4].search(Long=-13371337) + assert record.Long == -13371337 + + assert table.indexes[5].name == "IxCurrenc" + assert table.indexes[5].column_ids == [6] + record = table.indexes[5].search(Currency=1337133713371337) + assert record.Currency == 1337133713371337 + + assert table.indexes[6].name == "IxIEEESingle" + assert table.indexes[6].column_ids == [7] + record = table.indexes[6].search(IEEESingle=1.0) + assert record.IEEESingle == 1.0 + + assert table.indexes[7].name == "IxIEEEDouble" + assert table.indexes[7].column_ids == [8] + record = table.indexes[7].search(IEEEDouble=13371337.13371337) + assert record.IEEEDouble == 13371337.13371337 + + assert table.indexes[8].name == "IxDateTime" + assert table.indexes[8].column_ids == [9] + record = table.indexes[8].search(DateTime=4675210852477960192) + assert record.DateTime == 4675210852477960192 + + assert table.indexes[9].name == "IxUnsignedLong" + assert table.indexes[9].column_ids == [10] + record = table.indexes[9].search(UnsignedLong=13371337) + assert record.UnsignedLong == 13371337 + + assert table.indexes[10].name == "IxLongLong" + assert table.indexes[10].column_ids == [11] + record = table.indexes[10].search(LongLong=-13371337) + assert record.LongLong == -13371337 + + assert table.indexes[11].name == "IxGUID" + assert table.indexes[11].column_ids == [12] + record = table.indexes[11].search(GUID="3f360af1-6766-46dc-9af2-0dacf295c2a1") + assert record.GUID == "3f360af1-6766-46dc-9af2-0dacf295c2a1" + + assert table.indexes[12].name == "IxUnsignedShort" + assert table.indexes[12].column_ids == [13] + record = table.indexes[12].search(UnsignedShort=1337) + assert record.UnsignedShort == 1337 + + assert table.indexes[13].name == "IxBinary" + assert table.indexes[13].column_ids == [128] + record = table.indexes[13].search(Binary=b"test binary data") + assert record.Binary == b"test binary data" + + assert table.indexes[14].name == "IxLongBinary" + assert table.indexes[14].column_ids == [256] + record = table.indexes[14].search(LongBinary=b"test long binary data " + (b"a" * 1000)) + assert record.LongBinary == b"test long binary data " + (b"a" * 1000) + + assert table.indexes[15].name == "IxASCII" + assert table.indexes[15].column_ids == [129] + record = table.indexes[15].search(ASCII="Simple ASCII text") + assert record.ASCII == "Simple ASCII text" + + assert table.indexes[16].name == "IxUnicode" + assert table.indexes[16].column_ids == [130] + record = table.indexes[16].search(Unicode="Simple Unicode text 🦊") + assert record.Unicode == "Simple Unicode text 🦊" + + assert table.indexes[17].name == "IxLongASCII" + assert table.indexes[17].column_ids == [257] + record = table.indexes[17].search(LongASCII="Long ASCII text " + ("a" * 1024)) + assert record.LongASCII == "Long ASCII text " + ("a" * 1024) + + assert table.indexes[18].name == "IxLongUnicode" + assert table.indexes[18].column_ids == [258] + record = table.indexes[18].search(LongUnicode="Long Unicode text 🦊 " + ("a" * 1024)) + assert record.LongUnicode == "Long Unicode text 🦊 " + ("a" * 1024) diff --git a/tests/ese/test_page.py b/tests/ese/test_page.py new file mode 100644 index 0000000..b99ab4e --- /dev/null +++ b/tests/ese/test_page.py @@ -0,0 +1,25 @@ +from unittest.mock import Mock + +from dissect.database.ese.c_ese import c_ese +from dissect.database.ese.page import Page + + +def test_tag_state() -> None: + mock_esedb = Mock() + mock_esedb.has_small_pages = True + + mock_header = c_ese.PGHDR( + itagState=0x2069, + ).dumps() + + page = Page(mock_esedb, 0, mock_header) + assert page.tag_reserved == 2 + assert page.tag_count == 0x69 + + mock_header = c_ese.PGHDR( + itagState=0x0069, + ).dumps() + + page = Page(mock_esedb, 0, mock_header) + assert page.tag_reserved == 1 + assert page.tag_count == 0x69 diff --git a/tests/ese/test_record.py b/tests/ese/test_record.py new file mode 100644 index 0000000..79dc077 --- /dev/null +++ b/tests/ese/test_record.py @@ -0,0 +1,81 @@ +from __future__ import annotations + +from typing import BinaryIO + +from dissect.database.ese.ese import ESE +from dissect.database.ese.record import Record + + +def test_as_dict(basic_db: BinaryIO) -> None: + db = ESE(basic_db) + table = db.table("basic") + + records = list(table.records()) + assert len(records) == 2 + + assert [r.as_dict() for r in records] == [ + { + "Id": 1, + "Bit": False, + "UnsignedByte": 213, + "Short": -1337, + "Long": -13371337, + "Currency": 1337133713371337, + "IEEESingle": 1.0, + "IEEEDouble": 13371337.13371337, + "DateTime": 4675210852477960192, + "UnsignedLong": 13371337, + "LongLong": -13371337, + "GUID": "3f360af1-6766-46dc-9af2-0dacf295c2a1", + "UnsignedShort": 1337, + }, + { + "Id": 2, + "Bit": True, + "UnsignedByte": 255, + "Short": 1339, + "Long": 13391339, + "Currency": -1339133913391339, + "IEEESingle": -2.0, + "IEEEDouble": -13391339.13391339, + "DateTime": -4537072128574357504, + }, + ] + + +def test_comparison(basic_db: BinaryIO) -> None: + db = ESE(basic_db) + table = db.table("basic") + + records = list(table.records()) + assert len(records) == 2 + + assert records[0] == records[0] + assert records[0] != records[1] + + obj = Record(table, records[0]._node) + assert records[0] == obj + assert records[0] is not obj + + assert records[0] < records[1] + assert records[0] <= records[1] + assert records[0] <= records[0] + + assert set(records) == {records[0], records[1]} + assert set(records) | {obj} == {records[0], records[1]} + + +def test_parse_value_encoding(windows_search_db: BinaryIO) -> None: + """Test if we can parse invalid utf-16-le (Long)Text columns. + + Resources: + - https://github.com/fox-it/dissect.esedb/pull/48 + """ + + db = ESE(windows_search_db) + table = db.table("SystemIndex_PropertyStore") + + record = table.search(WorkID=1017) + auto_summary = record.get("4625-System_Search_AutoSummary") + assert auto_summary.startswith("Hong Kong SCS AdobeMingStd-Light-Acro-HKscs-B5-H ASCII") + assert auto_summary.endswith("\\x4c\\xd8") diff --git a/tests/ese/test_table.py b/tests/ese/test_table.py new file mode 100644 index 0000000..062d920 --- /dev/null +++ b/tests/ese/test_table.py @@ -0,0 +1,32 @@ +from unittest.mock import MagicMock + +from dissect.database.ese.table import Table + + +def test_find_index() -> None: + mock_column_id = MagicMock() + mock_column_id.name = "Id" + mock_column_bit = MagicMock() + mock_column_bit.name = "Bit" + mock_column_unsigned_byte = MagicMock() + mock_column_unsigned_byte.name = "UnsignedByte" + + mock_idx_id = MagicMock(name="IxId") + mock_idx_id.is_primary = True + mock_idx_id.columns = [mock_column_id] + mock_idx_bit = MagicMock(name="IxBit") + mock_idx_bit.is_primary = False + mock_idx_bit.columns = [mock_column_bit] + mock_idx_multiple = MagicMock(name="IxMultiple") + mock_idx_multiple.is_primary = False + mock_idx_multiple.columns = [mock_column_bit, mock_column_unsigned_byte] + + table = Table(MagicMock(), 69, "index", indexes=[mock_idx_id, mock_idx_bit, mock_idx_multiple]) + + assert table.find_index(["Id"]) == mock_idx_id + assert table.find_index(["Bit"]) == mock_idx_bit + assert table.find_index(["Bit", "UnsignedByte"]) == mock_idx_multiple + assert table.find_index(["UnsignedByte", "Bit"]) == mock_idx_multiple + assert table.find_index(["UnsignedByte"]) is None + assert table.find_index(["Id", "Bit"]) == mock_idx_id + assert table.find_index(["Bit", "SomethingElse"]) == mock_idx_bit diff --git a/tests/ese/tools/__init__.py b/tests/ese/tools/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/ese/tools/test_sru.py b/tests/ese/tools/test_sru.py new file mode 100644 index 0000000..ed6dd22 --- /dev/null +++ b/tests/ese/tools/test_sru.py @@ -0,0 +1,12 @@ +from __future__ import annotations + +from typing import BinaryIO + +from dissect.database.ese.tools.sru import SRU + + +def test_sru(sru_db: BinaryIO) -> None: + db = SRU(sru_db) + + records = list(db.entries()) + assert len(records) == 220 diff --git a/tests/ese/tools/test_ual.py b/tests/ese/tools/test_ual.py new file mode 100644 index 0000000..a72c542 --- /dev/null +++ b/tests/ese/tools/test_ual.py @@ -0,0 +1,15 @@ +from __future__ import annotations + +from typing import BinaryIO + +from dissect.database.ese.tools.ual import UAL + + +def test_ual(ual_db: BinaryIO) -> None: + db = UAL(ual_db) + + assert len(list(db.get_table_records("CLIENTS"))) == 19 + assert len(list(db.get_table_records("ROLE_ACCESS"))) == 3 + assert len(list(db.get_table_records("VIRTUALMACHINES"))) == 0 + assert len(list(db.get_table_records("DNS"))) == 12 + assert len(list(db.get_table_records("SYSTEM_IDENTITY"))) == 0