├── .coveragerc ├── .gitignore ├── .travis.yml ├── ChaCha.py ├── HORST.py ├── LICENSE ├── README.md ├── SPHINCS.py ├── WOTSplus.py ├── blake.py ├── bytes_utils.py ├── requirements.txt ├── tests ├── __init__.py ├── test_BLAKE.py ├── test_ChaCha.py ├── test_HORST.py ├── test_SPHINCS.py ├── test_WOTSplus.py └── test_trees.py └── trees.py /.coveragerc: -------------------------------------------------------------------------------- 1 | [run] 2 | omit = 3 | */site-packages/* 4 | tests/* -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | __pycache__/ 2 | .coverage -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: python 2 | sudo: false 3 | 4 | python: 5 | - "3.3" 6 | - "3.4" 7 | - "3.5" 8 | 9 | install: 10 | - pip install -r requirements.txt 11 | - pip install coveralls 12 | 13 | script: 14 | - coverage run -m nose2 15 | 16 | after_success: 17 | - coveralls 18 | -------------------------------------------------------------------------------- /ChaCha.py: -------------------------------------------------------------------------------- 1 | from bytes_utils import ints_from_4bytes, ints_to_4bytes 2 | 3 | sigma = "expand 32-byte k" 4 | tau = "expand 16-byte k" 5 | 6 | 7 | class ChaCha(object): 8 | 9 | def __init__(self, key=None, iv=None, rounds=12): 10 | assert rounds & 1 == 0 11 | self.rounds = rounds 12 | if key is None: 13 | key = bytes(32) 14 | if iv is None: 15 | iv = bytes(8) 16 | assert len(key) in [16, 32] 17 | assert len(iv) == 8 18 | self.state = [] 19 | if len(key) == 32: 20 | c = bytes(sigma, 'latin-1') 21 | self.state += ints_from_4bytes(c) 22 | self.state += ints_from_4bytes(key) 23 | elif len(key) == 16: 24 | c = bytes(tau, 'latin-1') 25 | self.state += ints_from_4bytes(c) 26 | self.state += ints_from_4bytes(key) 27 | self.state += ints_from_4bytes(key) 28 | self.state += [0, 0] 29 | self.state += ints_from_4bytes(iv) 30 | 31 | def permuted(self, a): 32 | """Takes 16 integers or 64 bytes, returns the ChaCha-permuted bytes 33 | 34 | Note that this is more elaborate than in the reference code. 35 | This should make it easier to use the ChaCha-permutation on its own. 36 | """ # TODO find a nice way to split this without duplication 37 | assert (len(a) == 16 and all(type(i) is int for i in a) or 38 | len(a) == 64 and type(a) in [bytes, bytearray]) 39 | if len(a) == 64: 40 | x = list(ints_from_4bytes(a)) 41 | else: 42 | x = list(a) 43 | 44 | def ROL32(x, n): 45 | return ((x << n) & 0xFFFFFFFF) | (x >> (32 - n)) 46 | 47 | def quarterround(x, a, b, c, d): 48 | x[a] = (x[a] + x[b] & 0xFFFFFFFF); x[d] = ROL32(x[d] ^ x[a], 16) 49 | x[c] = (x[c] + x[d] & 0xFFFFFFFF); x[b] = ROL32(x[b] ^ x[c], 12) 50 | x[a] = (x[a] + x[b] & 0xFFFFFFFF); x[d] = ROL32(x[d] ^ x[a], 8) 51 | x[c] = (x[c] + x[d] & 0xFFFFFFFF); x[b] = ROL32(x[b] ^ x[c], 7) 52 | 53 | for i in range(0, self.rounds, 2): 54 | quarterround(x, 0, 4, 8, 12) 55 | quarterround(x, 1, 5, 9, 13) 56 | quarterround(x, 2, 6, 10, 14) 57 | quarterround(x, 3, 7, 11, 15) 58 | quarterround(x, 0, 5, 10, 15) 59 | quarterround(x, 1, 6, 11, 12) 60 | quarterround(x, 2, 7, 8, 13) 61 | quarterround(x, 3, 4, 9, 14) 62 | 63 | if len(a) == 16: 64 | for i in range(16): 65 | x[i] = (x[i] + a[i] & 0xFFFFFFFF) 66 | 67 | return b''.join(ints_to_4bytes(x)) 68 | 69 | def keystream(self, N=64): 70 | """Returns N bytes of keystream starting from the current state 71 | 72 | Note that if N is not a multiple of 64, some keystream is discarded.""" 73 | output = bytes() 74 | for n in range(N, 0, -64): 75 | output += self.permuted(self.state)[:min(n, 64)] 76 | self.state[12] += 1 77 | if self.state[12] & 0xFFFFFFFF == 0: 78 | self.state[13] += 1 79 | return output 80 | -------------------------------------------------------------------------------- /HORST.py: -------------------------------------------------------------------------------- 1 | import itertools 2 | from trees import hash_tree, auth_path, construct_root, root 3 | from bytes_utils import xor, chunkbytes 4 | 5 | 6 | class HORST(object): 7 | 8 | def __init__(self, n, m, k, tau, F, H, Gt): 9 | """Initialize HORST 10 | 11 | n -- length of hashes (in bits) 12 | m -- length of the message hash (in bits) 13 | k -- number of revealed secret-key elements per signature 14 | tau -- number of tree layers (2 ** tau is the number of sk elements) 15 | F -- function used hash the leaf nodes 16 | Gt -- PRG to generate the chain bases, based on seed and no. of bytes 17 | """ 18 | assert k*tau == m 19 | self.n = n 20 | self.m = m 21 | self.k = k 22 | self.tau = tau 23 | self.t = 1 << tau 24 | self.F = F 25 | self.H = H 26 | # minimising k(tau - x + 1) + 2^{x} implies maximising 'k*x - 2^{x}' 27 | self.x = max((k * x - (1 << x), x) for x in range(tau))[1] 28 | self.Gt = lambda seed: Gt(seed=seed, n=self.t * self.n // 8) 29 | 30 | def message_indices(self, m): 31 | M = chunkbytes(m, self.tau // 8) 32 | # the reference implementation uses 'idx = m[2*i] + (m[2*i+1]<<8)' 33 | # which suggests using little-endian byte order 34 | M = [int.from_bytes(Mi, byteorder='little') for Mi in M] 35 | return M 36 | 37 | def keygen(self, seed, masks): 38 | assert len(seed) == self.n // 8 39 | assert len(masks) >= 2 * self.tau 40 | sk = self.Gt(seed) 41 | sk = chunkbytes(sk, self.n // 8) 42 | L = list(map(self.F, sk)) 43 | H = lambda x, y, i: self.H(xor(x, masks[2*i]), xor(y, masks[2*i+1])) 44 | return root(hash_tree(H, L)) 45 | 46 | def sign(self, m, seed, masks): 47 | assert len(m) == self.m // 8 48 | assert len(seed) == self.n // 8 49 | assert len(masks) >= 2 * self.tau 50 | sk = self.Gt(seed) 51 | sk = chunkbytes(sk, self.n // 8) 52 | L = list(map(self.F, sk)) 53 | H = lambda x, y, i: self.H(xor(x, masks[2*i]), xor(y, masks[2*i+1])) 54 | tree = hash_tree(H, L) 55 | trunk = list(itertools.islice(tree, 0, self.tau - self.x)) 56 | sigma_k = next(tree) 57 | M = self.message_indices(m) 58 | pk = root(tree) 59 | # the SPHINCS paper suggests to put sigma_k at the end of sigma 60 | # but the reference code places it at the front 61 | return ([(sk[Mi], auth_path(trunk, Mi)) for Mi in M] + [sigma_k], pk) 62 | 63 | def verify(self, m, sig, masks): 64 | assert len(m) == self.m // 8 65 | assert len(masks) >= 2 * self.tau 66 | M = self.message_indices(m) 67 | H = lambda x, y, i: self.H(xor(x, masks[2*i]), xor(y, masks[2*i+1])) 68 | sigma_k = sig[-1] 69 | for (sk, path), Mi in zip(sig, M): 70 | leaf = self.F(sk) 71 | r = construct_root(H, path, leaf, Mi) 72 | # there is an error in the SPHINCS paper for this formula, as it 73 | # states that y_i = floor(M_i / 2^tau - x) 74 | # rather than y_i = floor(M_i / 2^{tau - x}) 75 | yi = Mi // (1 << (self.tau - self.x)) 76 | if r != sigma_k[yi]: 77 | return False 78 | Qtop = masks[2*(self.tau - self.x):] 79 | H = lambda x, y, i: self.H(xor(x, Qtop[2*i]), xor(y, Qtop[2*i+1])) 80 | return root(hash_tree(H, sigma_k)) 81 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | CC0 1.0 Universal 2 | 3 | Statement of Purpose 4 | 5 | The laws of most jurisdictions throughout the world automatically confer 6 | exclusive Copyright and Related Rights (defined below) upon the creator and 7 | subsequent owner(s) (each and all, an "owner") of an original work of 8 | authorship and/or a database (each, a "Work"). 9 | 10 | Certain owners wish to permanently relinquish those rights to a Work for the 11 | purpose of contributing to a commons of creative, cultural and scientific 12 | works ("Commons") that the public can reliably and without fear of later 13 | claims of infringement build upon, modify, incorporate in other works, reuse 14 | and redistribute as freely as possible in any form whatsoever and for any 15 | purposes, including without limitation commercial purposes. These owners may 16 | contribute to the Commons to promote the ideal of a free culture and the 17 | further production of creative, cultural and scientific works, or to gain 18 | reputation or greater distribution for their Work in part through the use and 19 | efforts of others. 20 | 21 | For these and/or other purposes and motivations, and without any expectation 22 | of additional consideration or compensation, the person associating CC0 with a 23 | Work (the "Affirmer"), to the extent that he or she is an owner of Copyright 24 | and Related Rights in the Work, voluntarily elects to apply CC0 to the Work 25 | and publicly distribute the Work under its terms, with knowledge of his or her 26 | Copyright and Related Rights in the Work and the meaning and intended legal 27 | effect of CC0 on those rights. 28 | 29 | 1. Copyright and Related Rights. A Work made available under CC0 may be 30 | protected by copyright and related or neighboring rights ("Copyright and 31 | Related Rights"). Copyright and Related Rights include, but are not limited 32 | to, the following: 33 | 34 | i. the right to reproduce, adapt, distribute, perform, display, communicate, 35 | and translate a Work; 36 | 37 | ii. moral rights retained by the original author(s) and/or performer(s); 38 | 39 | iii. publicity and privacy rights pertaining to a person's image or likeness 40 | depicted in a Work; 41 | 42 | iv. rights protecting against unfair competition in regards to a Work, 43 | subject to the limitations in paragraph 4(a), below; 44 | 45 | v. rights protecting the extraction, dissemination, use and reuse of data in 46 | a Work; 47 | 48 | vi. database rights (such as those arising under Directive 96/9/EC of the 49 | European Parliament and of the Council of 11 March 1996 on the legal 50 | protection of databases, and under any national implementation thereof, 51 | including any amended or successor version of such directive); and 52 | 53 | vii. other similar, equivalent or corresponding rights throughout the world 54 | based on applicable law or treaty, and any national implementations thereof. 55 | 56 | 2. Waiver. To the greatest extent permitted by, but not in contravention of, 57 | applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and 58 | unconditionally waives, abandons, and surrenders all of Affirmer's Copyright 59 | and Related Rights and associated claims and causes of action, whether now 60 | known or unknown (including existing as well as future claims and causes of 61 | action), in the Work (i) in all territories worldwide, (ii) for the maximum 62 | duration provided by applicable law or treaty (including future time 63 | extensions), (iii) in any current or future medium and for any number of 64 | copies, and (iv) for any purpose whatsoever, including without limitation 65 | commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes 66 | the Waiver for the benefit of each member of the public at large and to the 67 | detriment of Affirmer's heirs and successors, fully intending that such Waiver 68 | shall not be subject to revocation, rescission, cancellation, termination, or 69 | any other legal or equitable action to disrupt the quiet enjoyment of the Work 70 | by the public as contemplated by Affirmer's express Statement of Purpose. 71 | 72 | 3. Public License Fallback. Should any part of the Waiver for any reason be 73 | judged legally invalid or ineffective under applicable law, then the Waiver 74 | shall be preserved to the maximum extent permitted taking into account 75 | Affirmer's express Statement of Purpose. In addition, to the extent the Waiver 76 | is so judged Affirmer hereby grants to each affected person a royalty-free, 77 | non transferable, non sublicensable, non exclusive, irrevocable and 78 | unconditional license to exercise Affirmer's Copyright and Related Rights in 79 | the Work (i) in all territories worldwide, (ii) for the maximum duration 80 | provided by applicable law or treaty (including future time extensions), (iii) 81 | in any current or future medium and for any number of copies, and (iv) for any 82 | purpose whatsoever, including without limitation commercial, advertising or 83 | promotional purposes (the "License"). The License shall be deemed effective as 84 | of the date CC0 was applied by Affirmer to the Work. Should any part of the 85 | License for any reason be judged legally invalid or ineffective under 86 | applicable law, such partial invalidity or ineffectiveness shall not 87 | invalidate the remainder of the License, and in such case Affirmer hereby 88 | affirms that he or she will not (i) exercise any of his or her remaining 89 | Copyright and Related Rights in the Work or (ii) assert any associated claims 90 | and causes of action with respect to the Work, in either case contrary to 91 | Affirmer's express Statement of Purpose. 92 | 93 | 4. Limitations and Disclaimers. 94 | 95 | a. No trademark or patent rights held by Affirmer are waived, abandoned, 96 | surrendered, licensed or otherwise affected by this document. 97 | 98 | b. Affirmer offers the Work as-is and makes no representations or warranties 99 | of any kind concerning the Work, express, implied, statutory or otherwise, 100 | including without limitation warranties of title, merchantability, fitness 101 | for a particular purpose, non infringement, or the absence of latent or 102 | other defects, accuracy, or the present or absence of errors, whether or not 103 | discoverable, all to the greatest extent permissible under applicable law. 104 | 105 | c. Affirmer disclaims responsibility for clearing rights of other persons 106 | that may apply to the Work or any use thereof, including without limitation 107 | any person's Copyright and Related Rights in the Work. Further, Affirmer 108 | disclaims responsibility for obtaining any necessary consents, permissions 109 | or other rights required for any use of the Work. 110 | 111 | d. Affirmer understands and acknowledges that Creative Commons is not a 112 | party to this document and has no duty or obligation with respect to this 113 | CC0 or use of the Work. 114 | 115 | For more information, please see 116 | 117 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## SPHINCS in Python [![Build Status](https://travis-ci.org/joostrijneveld/SPHINCS-py.svg?branch=master)](https://travis-ci.org/joostrijneveld/SPHINCS-py) [![Coverage Status](https://coveralls.io/repos/joostrijneveld/SPHINCS-py/badge.svg?branch=master&service=github)](https://coveralls.io/github/joostrijneveld/SPHINCS-py?branch=master) 2 | 3 | This repository contains an implementation of the hash-based signature scheme [SPHINCS](http://sphincs.cr.yp.to/), in Python. The goal for this implementation was not to be fast, secure, or in any other way useable in a production environment. This cannot be stressed enough. **DO NOT USE THIS** for any signature that you or others rely on in any way. 4 | 5 | Instead, this code was written to aid in understanding of the SPHINCS scheme, and to make it easier to experiment with the individual parts. The main aim was for the code to be flexible and (to some extent) readable. 6 | 7 | #### Third party code 8 | 9 | This project relies on the [Python implementation of BLAKE](http://www.seanet.com/~bugbee/crypto/blake/), by Larry Bugbee. This code was optimised for speed, but it is considered out of the scope of this repository to re-implement BLAKE from scratch. 10 | 11 | ### Using this code 12 | 13 | In order to be able to run the code, make sure the requirements listed in `requirements.txt` are satisfied. This can be achieved by calling `pip install -r requirements.txt` 14 | 15 | The `SPHINCS.py` can be called as an executable, according to the commandline interface specified below. Note again that this implementation is not optimised for speed - it takes some time to produce a signature using the default SPHINCS-256 parameters. 16 | 17 | ``` 18 | Usage: 19 | SPHINCS.py keygen [--secret-key FILE] [--public-key FILE] 20 | SPHINCS.py sign [-m FILE|--message FILE] [--secret-key FILE] [-s FILE|--signature FILE] 21 | SPHINCS.py verify [-m FILE|--message FILE] [-s FILE|--signature FILE] [--public-key FILE] 22 | SPHINCS.py (-h|--help) 23 | 24 | Options: 25 | -s FILE, --signature FILE Specify a signature file. 26 | -m FILE, --message FILE Specify a message file. 27 | --secret-key FILE Specify a secret-key file. 28 | --public-key FILE Specify a public-key file. 29 | ``` 30 | 31 | #### Unit tests 32 | 33 | This project includes several extensive unit tests. They are comptabile with `nose2`, so calling `nose2` from the project root directory is the easiest way to execute these. 34 | 35 | ### Relation to reference implementation 36 | 37 | This implementation was constructed based on the descriptions in the paper that introduces SPHINCS [1], rather than using the provided reference implementation. This leads to a few noteworthy design choices. 38 | 39 | - In the paper, the addresses are specifies as 3-tuples of integers. In order to use these for seed generation, they need to be converted to byte sequences. The convention chosen in the reference implementation (i.e. leaf-first concatenation and litte-endian conversion) is adhered to here as well. 40 | - The paper specifies that, with _R = (R1, R2)_ ∈ {0, 1}n x {0, 1}n, the leaf index i is defined as _i =_ Chop(_R2, h_). The reference implementation uses the rightmost chunk of 64 bits to compute _i_, however, and starts selecting bits for R1 from the third chunk. This implementation explicitly uses the bits from _R_ from start to end instead, effectively interpreting _R = F(M, SK2)_ as big-endian. See [`SPHINCS.py:110`](https://github.com/joostrijneveld/SPHINCS-py/blob/master/SPHINCS.py#L110) and onwards. In order to make the C code behave identically, one needs to explicitly use a big-endian byte order to initialise _i_ as well. 41 | - When computing the digest, the reference implementation currently includes the public key, i.e. _D = H(R1 | Q | PK1 | M)_. This implementation uses _D = H(R1 | M)_, as is specified in the paper. 42 | 43 | All of the above implies that the test vectors for WOTS+ and HORST (and ChaCha and BLAKE) provided in the `tests/` directory match the results from the reference implementation, but the example signature for SPHINCS-256 does not. To get these to match, one needs to account for the above differences. 44 | 45 | - - - 46 | 47 | [1] Daniel J. Bernstein, Daira Hopwood, Andreas Hülsing, Tanja Lange, Ruben Niederhagen, Louiza Papachristodoulou, Peter Schwabe, and Zooko Wilcox- O’Hearn. SPHINCS: practical stateless hash-based signatures. In Marc Fischlin and Elisabeth Oswald, editors, _Advances in Cryptology – EUROCRYPT 2015_, volume 9056 of _LNCS_, pages 368–397. Springer, 2015. Document ID: 5c2820cfddf4e259cc7ea1eda384c9f9, http://cryptojedi.org/papers/#sphincs. 48 | -------------------------------------------------------------------------------- /SPHINCS.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | """Python implementation of the SPHINCS signature scheme 3 | 4 | Usage: 5 | SPHINCS.py keygen [--secret-key FILE] [--public-key FILE] 6 | SPHINCS.py sign [-m FILE|--message FILE] [--secret-key FILE] [-s FILE|--signature FILE] 7 | SPHINCS.py verify [-m FILE|--message FILE] [-s FILE|--signature FILE] [--public-key FILE] 8 | SPHINCS.py (-h|--help) 9 | 10 | Options: 11 | -s FILE, --signature FILE Specify a signature file. 12 | -m FILE, --message FILE Specify a message file. 13 | --secret-key FILE Specify a secret-key file. 14 | --public-key FILE Specify a public-key file. 15 | -h --help Show this help screen. 16 | """ 17 | 18 | import sys 19 | import docopt 20 | import os 21 | from math import ceil, log 22 | 23 | from ChaCha import ChaCha 24 | from WOTSplus import WOTSplus 25 | from HORST import HORST 26 | from bytes_utils import xor 27 | from blake import BLAKE 28 | from trees import l_tree, hash_tree, auth_path, construct_root, root 29 | 30 | 31 | class SPHINCS(object): 32 | 33 | def __init__(self, n=256, m=512, h=60, d=12, w=16, tau=16, k=32): 34 | """Initializes SPHINCS (default to SPHINCS-256) 35 | 36 | Currently other parameters than SPHINCS-256 can be buggy 37 | n -- length of hash in WOTS / HORST (in bits) 38 | m -- length of message hash (in bits) 39 | h -- height of the hyper-tree 40 | d -- layers of the hyper-tree 41 | w -- Winternitz parameter used for WOTS signature 42 | tau -- layers in the HORST tree (2^tau is no. of secret-key elements) 43 | k -- number of revealed secret-key elements per HORST signature 44 | """ 45 | self.n = n 46 | self.m = m 47 | self.h = h 48 | self.d = d 49 | self.w = w 50 | self.tau = tau 51 | self.t = 1 << tau 52 | self.k = k 53 | 54 | self.Hdigest = lambda r, m: BLAKE(512).digest(r + m) 55 | self.Fa = lambda a, k: BLAKE(256).digest(k + a) 56 | self.Frand = lambda m, k: BLAKE(512).digest(k + m) 57 | 58 | C = bytes("expand 32-byte to 64-byte state!", 'latin-1') 59 | perm = ChaCha().permuted 60 | self.Glambda = lambda seed, n: ChaCha(key=seed).keystream(n) 61 | self.F = lambda m: perm(m + C)[:32] 62 | self.H = lambda m1, m2: perm(xor(perm(m1 + C), m2 + bytes(32)))[:32] 63 | 64 | self.wots = WOTSplus(n=n, w=w, F=self.F, Gl=self.Glambda) 65 | self.horst = HORST(n=n, m=m, k=k, tau=tau, 66 | F=self.F, H=self.H, Gt=self.Glambda) 67 | 68 | @classmethod 69 | def address(self, level, subtree, leaf): 70 | t = level | (subtree << 4) | (leaf << 59) 71 | return int.to_bytes(t, length=8, byteorder='little') 72 | 73 | def wots_leaf(self, address, SK1, masks): 74 | seed = self.Fa(address, SK1) 75 | pk_A = self.wots.keygen(seed, masks) 76 | H = lambda x, y, i: self.H(xor(x, masks[2*i]), xor(y, masks[2*i+1])) 77 | return root(l_tree(H, pk_A)) 78 | 79 | def wots_path(self, a, SK1, Q, subh): 80 | ta = dict(a) 81 | leafs = [] 82 | for subleaf in range(1 << subh): 83 | ta['leaf'] = subleaf 84 | leafs.append(self.wots_leaf(self.address(**ta), SK1, Q)) 85 | Qtree = Q[2 * ceil(log(self.wots.l, 2)):] 86 | H = lambda x, y, i: self.H(xor(x, Qtree[2*i]), xor(y, Qtree[2*i+1])) 87 | tree = list(hash_tree(H, leafs)) 88 | return auth_path(tree, a['leaf']), root(tree) 89 | 90 | def keygen(self): 91 | SK1 = os.urandom(self.n // 8) 92 | SK2 = os.urandom(self.n // 8) 93 | p = max(self.w-1, 2 * (self.h + ceil(log(self.wots.l, 2))), 2*self.tau) 94 | Q = [os.urandom(self.n // 8) for _ in range(p)] 95 | PK1 = self.keygen_pub(SK1, Q) 96 | return (SK1, SK2, Q), (PK1, Q) 97 | 98 | def keygen_pub(self, SK1, Q): 99 | addresses = [self.address(self.d - 1, 0, i) 100 | for i in range(1 << (self.h//self.d))] 101 | leafs = [self.wots_leaf(A, SK1, Q) for A in addresses] 102 | Qtree = Q[2 * ceil(log(self.wots.l, 2)):] 103 | H = lambda x, y, i: self.H(xor(x, Qtree[2*i]), xor(y, Qtree[2*i+1])) 104 | PK1 = root(hash_tree(H, leafs)) 105 | return PK1 106 | 107 | def sign(self, M, SK): 108 | SK1, SK2, Q = SK 109 | R = self.Frand(M, SK2) 110 | R1, R2 = R[:self.n // 8], R[self.n // 8:] 111 | D = self.Hdigest(R1, M) 112 | i = int.from_bytes(R2, byteorder='big') 113 | i >>= self.n - self.h 114 | subh = self.h // self.d 115 | a = {'level': self.d, 116 | 'subtree': i >> subh, 117 | 'leaf': i & ((1 << subh) - 1)} 118 | a_horst = self.address(**a) 119 | seed_horst = self.Fa(a_horst, SK1) 120 | sig_horst, pk_horst = self.horst.sign(D, seed_horst, Q) 121 | pk = pk_horst 122 | sig = [i, R1, sig_horst] 123 | for level in range(self.d): 124 | a['level'] = level 125 | a_wots = self.address(**a) 126 | seed_wots = self.Fa(a_wots, SK1) 127 | wots_sig = self.wots.sign(pk, seed_wots, Q) 128 | sig.append(wots_sig) 129 | path, pk = self.wots_path(a, SK1, Q, subh) 130 | sig.append(path) 131 | a['leaf'] = a['subtree'] & ((1 << subh) - 1) 132 | a['subtree'] >>= subh 133 | return tuple(sig) 134 | 135 | def verify(self, M, sig, PK): 136 | i, R1, sig_horst, *sig = sig 137 | PK1, Q = PK 138 | Qtree = Q[2 * ceil(log(self.wots.l, 2)):] 139 | D = self.Hdigest(R1, M) 140 | pk = pk_horst = self.horst.verify(D, sig_horst, Q) 141 | if pk_horst is False: 142 | return False 143 | subh = self.h // self.d 144 | H = lambda x, y, i: self.H(xor(x, Q[2*i]), xor(y, Q[2*i+1])) 145 | Ht = lambda x, y, i: self.H(xor(x, Qtree[2*i]), xor(y, Qtree[2*i+1])) 146 | for _ in range(self.d): 147 | wots_sig, wots_path, *sig = sig 148 | pk_wots = self.wots.verify(pk, wots_sig, Q) 149 | leaf = root(l_tree(H, pk_wots)) 150 | pk = construct_root(Ht, wots_path, leaf, i & 0x1f) 151 | i >>= subh 152 | return PK1 == pk 153 | 154 | def pack(self, x): 155 | if type(x) is bytes: 156 | return x 157 | if type(x) is int: # needed for index i 158 | return int.to_bytes(x, length=(self.h+7)//8, byteorder='little') 159 | return b''.join([self.pack(a) for a in iter(x)]) 160 | 161 | def unpack(self, sk=None, pk=None, sig=None, byteseq=None): 162 | n = self.n // 8 163 | if sk: 164 | return sk[:n], sk[n:2*n], self.unpack(byteseq=sk[2*n:]) 165 | elif pk: 166 | return pk[:n], self.unpack(byteseq=pk[n:]) 167 | elif byteseq: 168 | return [byteseq[i:i+n] for i in range(0, len(byteseq), n)] 169 | elif sig: 170 | def prefix(x, n): 171 | return x[:n], x[n:] 172 | i, sig = prefix(sig, (self.h+7)//8) 173 | i = int.from_bytes(i, byteorder='little') 174 | R1, sig = prefix(sig, n) 175 | sig_horst = [] 176 | for _ in range(self.k): 177 | sk, sig = prefix(sig, n) 178 | auth, sig = prefix(sig, (self.tau - self.horst.x)*n) 179 | sig_horst.append((sk, self.unpack(byteseq=auth))) 180 | sigma_k, sig = prefix(sig, (1 << self.horst.x) * n) 181 | sig_horst.append(self.unpack(byteseq=sigma_k)) 182 | wots = [] 183 | for _ in range(self.d): 184 | wots_sig, sig = prefix(sig, self.wots.l*n) 185 | path, sig = prefix(sig, self.h//self.d*n) 186 | wots.append(self.unpack(byteseq=wots_sig)) 187 | wots.append(self.unpack(byteseq=path)) 188 | return (i, R1, sig_horst) + tuple(wots) 189 | 190 | if __name__ == "__main__": 191 | args = docopt.docopt(__doc__) 192 | sphincs256 = SPHINCS() 193 | 194 | for f in ['--signature', '--message', '--secret-key', '--public-key']: 195 | if args[f] is None or args[f] == '-': 196 | args[f] = None 197 | if args['keygen']: 198 | ihandles, ohandles = [], ['--secret-key', '--public-key'] 199 | elif args['sign']: 200 | ihandles, ohandles = ['--message', '--secret-key'], ['--signature'] 201 | elif args['verify']: 202 | ihandles, ohandles = ['--message', '--public-key', '--signature'], [] 203 | 204 | fh = {} 205 | for f in ihandles: 206 | if args[f] is None: 207 | fh[f[2:]] = sys.stdin.buffer 208 | else: 209 | fh[f[2:]] = open(args[f], 'rb') 210 | for f in ohandles: 211 | if args[f] is None: 212 | fh[f[2:]] = sys.stdout.buffer 213 | else: 214 | fh[f[2:]] = open(args[f], 'wb') 215 | 216 | if args['keygen']: 217 | print("Generating keys..", file=sys.stderr) 218 | sk, pk = sphincs256.keygen() 219 | fh['secret-key'].write(sphincs256.pack(sk)) 220 | fh['public-key'].write(sphincs256.pack(pk)) 221 | print('Wrote keys', file=sys.stderr) 222 | elif args['sign']: 223 | message = fh['message'].read() 224 | sk = sphincs256.unpack(sk=fh['secret-key'].read()) 225 | print("Signing..", file=sys.stderr) 226 | signature = sphincs256.sign(message, sk) 227 | fh['signature'].write(sphincs256.pack(signature)) 228 | print('Wrote signature', file=sys.stderr) 229 | elif args['verify']: 230 | message = fh['message'].read() 231 | sig = sphincs256.unpack(sig=fh['signature'].read()) 232 | pk = sphincs256.unpack(pk=fh['public-key'].read()) 233 | print("Verifying..", file=sys.stderr) 234 | if sphincs256.verify(message, sig, pk): 235 | print('Verification succeeded', file=sys.stderr) 236 | else: 237 | print('Verification failed', file=sys.stderr) 238 | 239 | for f in fh.values(): 240 | f.close() 241 | -------------------------------------------------------------------------------- /WOTSplus.py: -------------------------------------------------------------------------------- 1 | from math import ceil, floor, log2 2 | from bytes_utils import xor, chunkbytes 3 | 4 | 5 | class WOTSplus(object): 6 | 7 | def __init__(self, n, w, F, Gl): 8 | """Initializes WOTS+ 9 | 10 | n -- length of hashes (in bits) 11 | w -- Winternitz parameter; chain length and block size trade-off 12 | F -- function used to construct chains (n/8 bytes -> n/8 bytes) 13 | Gl -- PRG to generate the chain bases, based on seed and no. of bytes 14 | """ 15 | self.n = n 16 | self.w = w 17 | self.l1 = ceil(n / log2(w)) 18 | self.l2 = floor(log2(self.l1 * (w - 1)) / log2(w)) + 1 19 | self.l = self.l1 + self.l2 20 | self.F = F 21 | self.Gl = lambda seed: Gl(seed=seed, n=self.l * self.n // 8) 22 | 23 | def chains(self, x, masks, chainrange): 24 | x = list(x) 25 | for i in range(self.l): 26 | for j in chainrange[i]: 27 | x[i] = self.F(xor(x[i], masks[j])) 28 | return x 29 | 30 | def int_to_basew(self, x, base): 31 | for _ in range(self.l1): 32 | yield x % base 33 | x //= base 34 | 35 | def chainlengths(self, m): 36 | M = int.from_bytes(m, byteorder='little') 37 | M = list(self.int_to_basew(M, self.w)) 38 | C = sum(self.w - 1 - M[i] for i in range(self.l1)) 39 | C = list(self.int_to_basew(C, self.w)) 40 | return M + C 41 | 42 | def keygen(self, seed, masks): 43 | sk = self.Gl(seed) 44 | sk = chunkbytes(sk, self.n // 8) 45 | return self.chains(sk, masks, [range(0, self.w-1)]*self.l) 46 | 47 | def sign(self, m, seed, masks): 48 | sk = self.Gl(seed) 49 | sk = chunkbytes(sk, self.n // 8) 50 | B = self.chainlengths(m) 51 | return self.chains(sk, masks, [range(0, b) for b in B]) 52 | 53 | def verify(self, m, sig, masks): 54 | B = self.chainlengths(m) 55 | return self.chains(sig, masks, [range(b, self.w-1) for b in B]) 56 | -------------------------------------------------------------------------------- /blake.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | intro = """ 4 | blake.py 5 | version 5, 2-Apr-2014 6 | 7 | BLAKE is a SHA3 round-3 finalist designed and submitted by 8 | Jean-Philippe Aumasson et al. 9 | 10 | At the core of BLAKE is a ChaCha-like mixer, very similar 11 | to that found in the stream cipher, ChaCha8. Besides being 12 | a very good mixer, ChaCha is fast. 13 | 14 | References: 15 | http://www.131002.net/blake/ 16 | http://csrc.nist.gov/groups/ST/hash/sha-3/index.html 17 | http://en.wikipedia.org/wiki/BLAKE_(hash_function) 18 | 19 | This implementation assumes all data is in increments of 20 | whole bytes. (The formal definition of BLAKE allows for 21 | hashing individual bits.) Note too that this implementation 22 | does include the round-3 tweaks where the number of rounds 23 | was increased to 14/16 from 10/14. 24 | 25 | This version can be imported into both Python2 (2.6 and 2.7) 26 | and Python3 programs. Python 2.5 requires an older version 27 | of blake.py (version 4). 28 | 29 | Here are some comparative times for different versions of 30 | Python: 31 | 32 | 64-bit: 33 | 2.6 6.284s 34 | 2.7 6.343s 35 | 3.2 7.620s 36 | pypy (2.7) 2.080s 37 | 38 | 32-bit: 39 | 2.5 (32) 15.389s (with psyco) 40 | 2.7-32 13.645s 41 | 3.2-32 12.574s 42 | 43 | One test on a 2.0GHz Core 2 Duo of 10,000 iterations of 44 | BLAKE-256 on a short message produced a time of 5.7 seconds. 45 | Not bad, but if raw speed is what you want, look to the 46 | the C version. It is 40x faster and did the same thing 47 | in 0.13 seconds. 48 | 49 | Copyright (c) 2009-2012 by Larry Bugbee, Kent, WA 50 | ALL RIGHTS RESERVED. 51 | 52 | blake.py IS EXPERIMENTAL SOFTWARE FOR EDUCATIONAL 53 | PURPOSES ONLY. IT IS MADE AVAILABLE "AS-IS" WITHOUT 54 | WARRANTY OR GUARANTEE OF ANY KIND. USE SIGNIFIES 55 | ACCEPTANCE OF ALL RISK. 56 | 57 | To make your learning and experimentation less cumbersome, 58 | blake.py is free for any use. 59 | 60 | Enjoy, 61 | 62 | Larry Bugbee 63 | March 2011 64 | rev May 2011 - fixed Python version check (tx JP) 65 | rev Apr 2012 - fixed an out-of-order bit set in final() 66 | - moved self-test to a separate test pgm 67 | - this now works with Python2 and Python3 68 | rev Apr 2014 - added test and conversion of string input 69 | to byte string in update() (tx Soham) 70 | - added hexdigest() method. 71 | - now support state 3 so only one call to 72 | final() per instantiation is allowed. all 73 | subsequent calls to final(), digest() or 74 | hexdigest() simply return the stored value. 75 | 76 | """ 77 | 78 | import struct 79 | from binascii import hexlify, unhexlify 80 | 81 | #--------------------------------------------------------------- 82 | 83 | class BLAKE(object): 84 | 85 | # - - - - - - - - - - - - - - - - - - - - - - - - - - - 86 | # initial values, constants and padding 87 | 88 | # IVx for BLAKE-x 89 | 90 | IV64 = [ 91 | 0x6A09E667F3BCC908, 0xBB67AE8584CAA73B, 92 | 0x3C6EF372FE94F82B, 0xA54FF53A5F1D36F1, 93 | 0x510E527FADE682D1, 0x9B05688C2B3E6C1F, 94 | 0x1F83D9ABFB41BD6B, 0x5BE0CD19137E2179, 95 | ] 96 | 97 | IV48 = [ 98 | 0xCBBB9D5DC1059ED8, 0x629A292A367CD507, 99 | 0x9159015A3070DD17, 0x152FECD8F70E5939, 100 | 0x67332667FFC00B31, 0x8EB44A8768581511, 101 | 0xDB0C2E0D64F98FA7, 0x47B5481DBEFA4FA4, 102 | ] 103 | 104 | # note: the values here are the same as the high-order 105 | # half-words of IV64 106 | IV32 = [ 107 | 0x6A09E667, 0xBB67AE85, 108 | 0x3C6EF372, 0xA54FF53A, 109 | 0x510E527F, 0x9B05688C, 110 | 0x1F83D9AB, 0x5BE0CD19, 111 | ] 112 | 113 | # note: the values here are the same as the low-order 114 | # half-words of IV48 115 | IV28 = [ 116 | 0xC1059ED8, 0x367CD507, 117 | 0x3070DD17, 0xF70E5939, 118 | 0xFFC00B31, 0x68581511, 119 | 0x64F98FA7, 0xBEFA4FA4, 120 | ] 121 | 122 | # constants for BLAKE-64 and BLAKE-48 123 | C64 = [ 124 | 0x243F6A8885A308D3, 0x13198A2E03707344, 125 | 0xA4093822299F31D0, 0x082EFA98EC4E6C89, 126 | 0x452821E638D01377, 0xBE5466CF34E90C6C, 127 | 0xC0AC29B7C97C50DD, 0x3F84D5B5B5470917, 128 | 0x9216D5D98979FB1B, 0xD1310BA698DFB5AC, 129 | 0x2FFD72DBD01ADFB7, 0xB8E1AFED6A267E96, 130 | 0xBA7C9045F12C7F99, 0x24A19947B3916CF7, 131 | 0x0801F2E2858EFC16, 0x636920D871574E69, 132 | ] 133 | 134 | # constants for BLAKE-32 and BLAKE-28 135 | # note: concatenate and the values are the same as the values 136 | # for the 1st half of C64 137 | C32 = [ 138 | 0x243F6A88, 0x85A308D3, 139 | 0x13198A2E, 0x03707344, 140 | 0xA4093822, 0x299F31D0, 141 | 0x082EFA98, 0xEC4E6C89, 142 | 0x452821E6, 0x38D01377, 143 | 0xBE5466CF, 0x34E90C6C, 144 | 0xC0AC29B7, 0xC97C50DD, 145 | 0x3F84D5B5, 0xB5470917, 146 | ] 147 | 148 | # the 10 permutations of:0,...15} 149 | SIGMA = [ 150 | [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15], 151 | [14,10, 4, 8, 9,15,13, 6, 1,12, 0, 2,11, 7, 5, 3], 152 | [11, 8,12, 0, 5, 2,15,13,10,14, 3, 6, 7, 1, 9, 4], 153 | [ 7, 9, 3, 1,13,12,11,14, 2, 6, 5,10, 4, 0,15, 8], 154 | [ 9, 0, 5, 7, 2, 4,10,15,14, 1,11,12, 6, 8, 3,13], 155 | [ 2,12, 6,10, 0,11, 8, 3, 4,13, 7, 5,15,14, 1, 9], 156 | [12, 5, 1,15,14,13, 4,10, 0, 7, 6, 3, 9, 2, 8,11], 157 | [13,11, 7,14,12, 1, 3, 9, 5, 0,15, 4, 8, 6, 2,10], 158 | [ 6,15,14, 9,11, 3, 0, 8,12, 2,13, 7, 1, 4,10, 5], 159 | [10, 2, 8, 4, 7, 6, 1, 5,15,11, 9,14, 3,12,13, 0], 160 | [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15], 161 | [14,10, 4, 8, 9,15,13, 6, 1,12, 0, 2,11, 7, 5, 3], 162 | [11, 8,12, 0, 5, 2,15,13,10,14, 3, 6, 7, 1, 9, 4], 163 | [ 7, 9, 3, 1,13,12,11,14, 2, 6, 5,10, 4, 0,15, 8], 164 | [ 9, 0, 5, 7, 2, 4,10,15,14, 1,11,12, 6, 8, 3,13], 165 | [ 2,12, 6,10, 0,11, 8, 3, 4,13, 7, 5,15,14, 1, 9], 166 | [12, 5, 1,15,14,13, 4,10, 0, 7, 6, 3, 9, 2, 8,11], 167 | [13,11, 7,14,12, 1, 3, 9, 5, 0,15, 4, 8, 6, 2,10], 168 | [ 6,15,14, 9,11, 3, 0, 8,12, 2,13, 7, 1, 4,10, 5], 169 | [10, 2, 8, 4, 7, 6, 1, 5,15,11, 9,14, 3,12,13, 0], 170 | ] 171 | 172 | MASK32BITS = 0xFFFFFFFF 173 | MASK64BITS = 0xFFFFFFFFFFFFFFFF 174 | 175 | # - - - - - - - - - - - - - - - - - - - - - - - - - - - 176 | 177 | def __init__(self, hashbitlen): 178 | """ 179 | load the hashSate structure (copy hashbitlen...) 180 | hashbitlen: length of the hash output 181 | """ 182 | if hashbitlen not in [224, 256, 384, 512]: 183 | raise Exception('hash length not 224, 256, 384 or 512') 184 | 185 | self.hashbitlen = hashbitlen 186 | self.h = [0]*8 # current chain value (initialized to the IV) 187 | self.t = 0 # number of *BITS* hashed so far 188 | self.cache = b'' # cached leftover data not yet compressed 189 | self.salt = [0]*4 # salt (null by default) 190 | self.state = 1 # set to 2 by update and 3 by final 191 | self.nullt = 0 # Boolean value for special case \ell_i=0 192 | 193 | # The algorithm is the same for both the 32- and 64- versions 194 | # of BLAKE. The difference is in word size (4 vs 8 bytes), 195 | # blocksize (64 vs 128 bytes), number of rounds (14 vs 16) 196 | # and a few very specific constants. 197 | if (hashbitlen == 224) or (hashbitlen == 256): 198 | # setup for 32-bit words and 64-bit block 199 | self.byte2int = self._fourByte2int 200 | self.int2byte = self._int2fourByte 201 | self.MASK = self.MASK32BITS 202 | self.WORDBYTES = 4 203 | self.WORDBITS = 32 204 | self.BLKBYTES = 64 205 | self.BLKBITS = 512 206 | self.ROUNDS = 14 # was 10 before round 3 207 | self.cxx = self.C32 208 | self.rot1 = 16 # num bits to shift in G 209 | self.rot2 = 12 # num bits to shift in G 210 | self.rot3 = 8 # num bits to shift in G 211 | self.rot4 = 7 # num bits to shift in G 212 | self.mul = 0 # for 32-bit words, 32<>1 is the same as i/2 but faster) 266 | v[12] = v[12] ^ (self.t & MASK) 267 | v[13] = v[13] ^ (self.t & MASK) 268 | v[14] = v[14] ^ (self.t >> self.WORDBITS) 269 | v[15] = v[15] ^ (self.t >> self.WORDBITS) 270 | 271 | # - - - - - - - - - - - - - - - - - 272 | # ready? let's ChaCha!!! 273 | 274 | def G(a, b, c, d, i): 275 | va = v[a] # it's faster to deref and reref later 276 | vb = v[b] 277 | vc = v[c] 278 | vd = v[d] 279 | 280 | sri = SIGMA[round][i] 281 | sri1 = SIGMA[round][i+1] 282 | 283 | va = ((va + vb) + (m[sri] ^ cxx[sri1]) ) & MASK 284 | x = vd ^ va 285 | vd = (x >> rot1) | ((x << (WORDBITS-rot1)) & MASK) 286 | vc = (vc + vd) & MASK 287 | x = vb ^ vc 288 | vb = (x >> rot2) | ((x << (WORDBITS-rot2)) & MASK) 289 | 290 | va = ((va + vb) + (m[sri1] ^ cxx[sri]) ) & MASK 291 | x = vd ^ va 292 | vd = (x >> rot3) | ((x << (WORDBITS-rot3)) & MASK) 293 | vc = (vc + vd) & MASK 294 | x = vb ^ vc 295 | vb = (x >> rot4) | ((x << (WORDBITS-rot4)) & MASK) 296 | 297 | v[a] = va 298 | v[b] = vb 299 | v[c] = vc 300 | v[d] = vd 301 | 302 | for round in range(self.ROUNDS): 303 | # column step 304 | G( 0, 4, 8,12, 0) 305 | G( 1, 5, 9,13, 2) 306 | G( 2, 6,10,14, 4) 307 | G( 3, 7,11,15, 6) 308 | # diagonal step 309 | G( 0, 5,10,15, 8) 310 | G( 1, 6,11,12,10) 311 | G( 2, 7, 8,13,12) 312 | G( 3, 4, 9,14,14) 313 | 314 | # - - - - - - - - - - - - - - - - - 315 | 316 | # save current hash value (use i&0x3 to get 0,1,2,3,0,1,2,3) 317 | self.h = [self.h[i]^v[i]^v[i+8]^self.salt[i&0x3] 318 | for i in range(8)] 319 | # print 'self.h', [num2hex(h) for h in self.h] 320 | 321 | # - - - - - - - - - - - - - - - - - - - - - - - - - - - 322 | 323 | def addsalt(self, salt): 324 | """ adds a salt to the hash function (OPTIONAL) 325 | should be called AFTER Init, and BEFORE update 326 | salt: a bytestring, length determined by hashbitlen. 327 | if not of sufficient length, the bytestring 328 | will be assumed to be a big endian number and 329 | prefixed with an appropriate number of null 330 | bytes, and if too large, only the low order 331 | bytes will be used. 332 | 333 | if hashbitlen=224 or 256, then salt will be 16 bytes 334 | if hashbitlen=384 or 512, then salt will be 32 bytes 335 | """ 336 | # fail if addsalt() was not called at the right time 337 | if self.state != 1: 338 | raise Exception('addsalt() not called after init() and before update()') 339 | # salt size is to be 4x word size 340 | saltsize = self.WORDBYTES * 4 341 | # if too short, prefix with null bytes. if too long, 342 | # truncate high order bytes 343 | if len(salt) < saltsize: 344 | salt = (chr(0)*(saltsize-len(salt)) + salt) 345 | else: 346 | salt = salt[-saltsize:] 347 | # prep the salt array 348 | self.salt[0] = self.byte2int(salt[ : 4<= fill: 393 | self.cache = self.cache + data[:fill] 394 | self.t += BLKBITS # update counter 395 | self._compress(self.cache) 396 | self.cache = b'' 397 | data = data[fill:] 398 | datalen -= fill 399 | 400 | # compress new data until not enough for a full block 401 | while datalen >= BLKBYTES: 402 | self.t += BLKBITS # update counter 403 | self._compress(data[:BLKBYTES]) 404 | data = data[BLKBYTES:] 405 | datalen -= BLKBYTES 406 | 407 | # cache all leftover bytes until next call to update() 408 | if datalen > 0: 409 | self.cache = self.cache + data[:datalen] 410 | 411 | # - - - - - - - - - - - - - - - - - - - - - - - - - - - 412 | 413 | def final(self, data=''): 414 | """ finalize the hash -- pad and hash remaining data 415 | returns hashval, the digest 416 | """ 417 | if self.state == 3: 418 | # we have already finalized so simply return the 419 | # previously calculated/stored hash value 420 | return self.hash 421 | 422 | if data: 423 | self.update(data) 424 | 425 | ZZ = b'\x00' 426 | ZO = b'\x01' 427 | OZ = b'\x80' 428 | OO = b'\x81' 429 | PADDING = OZ + ZZ*128 # pre-formatted padding data 430 | 431 | # copy nb. bits hash in total as a 64-bit BE word 432 | # copy nb. bits hash in total as a 128-bit BE word 433 | tt = self.t + (len(self.cache) << 3) 434 | if self.BLKBYTES == 64: 435 | msglen = self._int2eightByte(tt) 436 | else: 437 | low = tt & self.MASK 438 | high = tt >> self.WORDBITS 439 | msglen = self._int2eightByte(high) + self._int2eightByte(low) 440 | 441 | # size of block without the words at the end that count 442 | # the number of bits, 55 or 111. 443 | # Note: (((self.WORDBITS/8)*2)+1) equals ((self.WORDBITS>>2)+1) 444 | sizewithout = self.BLKBYTES - ((self.WORDBITS>>2)+1) 445 | 446 | if len(self.cache) == sizewithout: 447 | # special case of one padding byte 448 | self.t -= 8 449 | if self.hashbitlen in [224, 384]: 450 | self.update(OZ) 451 | else: 452 | self.update(OO) 453 | else: 454 | if len(self.cache) < sizewithout: 455 | # enough space to fill the block 456 | # use t=0 if no remaining data 457 | if len(self.cache) == 0: 458 | self.nullt=1 459 | self.t -= (sizewithout - len(self.cache)) << 3 460 | self.update(PADDING[:sizewithout - len(self.cache)]) 461 | else: 462 | # NOT enough space, need 2 compressions 463 | # ...add marker, pad with nulls and compress 464 | self.t -= (self.BLKBYTES - len(self.cache)) << 3 465 | self.update(PADDING[:self.BLKBYTES - len(self.cache)]) 466 | # ...now pad w/nulls leaving space for marker & bit count 467 | self.t -= (sizewithout+1) << 3 468 | self.update(PADDING[1:sizewithout+1]) # pad with zeroes 469 | 470 | self.nullt = 1 # raise flag to set t=0 at the next _compress 471 | 472 | # append a marker byte 473 | if self.hashbitlen in [224, 384]: 474 | self.update(ZZ) 475 | else: 476 | self.update(ZO) 477 | self.t -= 8 478 | 479 | # append the number of bits (long long) 480 | self.t -= self.BLKBYTES 481 | self.update(msglen) 482 | 483 | hashval = [] 484 | if self.BLKBYTES == 64: 485 | for h in self.h: 486 | hashval.append(self._int2fourByte(h)) 487 | else: 488 | for h in self.h: 489 | hashval.append(self._int2eightByte(h)) 490 | 491 | self.hash = b''.join(hashval)[:self.hashbitlen >> 3] 492 | self.state = 3 493 | 494 | return self.hash 495 | 496 | digest = final # may use digest() as a synonym for final() 497 | 498 | # - - - - - - - - - - - - - - - - - - - - - - - - - - - 499 | 500 | def hexdigest(self, data=''): 501 | return hexlify(self.final(data)).decode('UTF-8') 502 | 503 | # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 504 | # utility functions 505 | 506 | def _fourByte2int(self, bytestr): # see also long2byt() below 507 | """ convert a 4-byte string to an int (long) """ 508 | return struct.unpack('!L', bytestr)[0] 509 | 510 | def _eightByte2int(self, bytestr): 511 | """ convert a 8-byte string to an int (long long) """ 512 | return struct.unpack('!Q', bytestr)[0] 513 | 514 | def _int2fourByte(self, x): # see also long2byt() below 515 | """ convert a number to a 4-byte string, high order 516 | truncation possible (in Python x could be a BIGNUM) 517 | """ 518 | return struct.pack('!L', x) 519 | 520 | def _int2eightByte(self, x): 521 | """ convert a number to a 8-byte string, high order 522 | truncation possible (in Python x could be a BIGNUM) 523 | """ 524 | return struct.pack('!Q', x) 525 | 526 | 527 | #--------------------------------------------------------------- 528 | #--------------------------------------------------------------- 529 | #--------------------------------------------------------------- 530 | -------------------------------------------------------------------------------- /bytes_utils.py: -------------------------------------------------------------------------------- 1 | def xor(b1, b2): 2 | """Expects two bytes objects of equal length, returns their XOR""" 3 | assert len(b1) == len(b2) 4 | return bytes([x ^ y for x, y in zip(b1, b2)]) 5 | 6 | 7 | def chunkbytes(a, n): 8 | return [a[i:i+n] for i in range(0, len(a), n)] 9 | 10 | 11 | def ints_from_4bytes(a): 12 | for chunk in chunkbytes(a, 4): 13 | yield int.from_bytes(chunk, byteorder='little') 14 | 15 | 16 | def ints_to_4bytes(x): 17 | for v in x: 18 | yield int.to_bytes(v, length=4, byteorder='little') 19 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | docopt==0.6.2 2 | nose2==0.5.0 3 | six==1.10.0 4 | -------------------------------------------------------------------------------- /tests/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joostrijneveld/SPHINCS-256-py/114017ff6ba7f396d789867e4b69b98fa6178822/tests/__init__.py -------------------------------------------------------------------------------- /tests/test_BLAKE.py: -------------------------------------------------------------------------------- 1 | from blake import BLAKE 2 | 3 | 4 | def test_BLAKE512_tc1(): 5 | result = bytes([0xa8, 0xcf, 0xbb, 0xd7, 0x37, 0x26, 0x06, 0x2d, 6 | 0xf0, 0xc6, 0x86, 0x4d, 0xda, 0x65, 0xde, 0xfe, 7 | 0x58, 0xef, 0x0c, 0xc5, 0x2a, 0x56, 0x25, 0x09, 8 | 0x0f, 0xa1, 0x76, 0x01, 0xe1, 0xee, 0xcd, 0x1b, 9 | 0x62, 0x8e, 0x94, 0xf3, 0x96, 0xae, 0x40, 0x2a, 10 | 0x00, 0xac, 0xc9, 0xea, 0xb7, 0x7b, 0x4d, 0x4c, 11 | 0x2e, 0x85, 0x2a, 0xaa, 0xa2, 0x5a, 0x63, 0x6d, 12 | 0x80, 0xaf, 0x3f, 0xc7, 0x91, 0x3e, 0xf5, 0xb8]) 13 | digest = BLAKE(512).digest(bytes(0)) 14 | assert result == digest 15 | 16 | 17 | def test_BLAKE512_tc2(): 18 | result = bytes([0x97, 0x96, 0x15, 0x87, 0xf6, 0xd9, 0x70, 0xfa, 19 | 0xba, 0x6d, 0x24, 0x78, 0x04, 0x5d, 0xe6, 0xd1, 20 | 0xfa, 0xbd, 0x09, 0xb6, 0x1a, 0xe5, 0x09, 0x32, 21 | 0x05, 0x4d, 0x52, 0xbc, 0x29, 0xd3, 0x1b, 0xe4, 22 | 0xff, 0x91, 0x02, 0xb9, 0xf6, 0x9e, 0x2b, 0xbd, 23 | 0xb8, 0x3b, 0xe1, 0x3d, 0x4b, 0x9c, 0x06, 0x09, 24 | 0x1e, 0x5f, 0xa0, 0xb4, 0x8b, 0xd0, 0x81, 0xb6, 25 | 0x34, 0x05, 0x8b, 0xe0, 0xec, 0x49, 0xbe, 0xb3]) 26 | digest = BLAKE(512).digest(bytes(1)) 27 | assert result == digest 28 | 29 | 30 | def test_BLAKE512_tc3(): 31 | result = bytes([0x1f, 0x7e, 0x26, 0xf6, 0x3b, 0x6a, 0xd2, 0x5a, 32 | 0x08, 0x96, 0xfd, 0x97, 0x8f, 0xd0, 0x50, 0xa1, 33 | 0x76, 0x63, 0x91, 0xd2, 0xfd, 0x04, 0x71, 0xa7, 34 | 0x7a, 0xfb, 0x97, 0x5e, 0x50, 0x34, 0xb7, 0xad, 35 | 0x2d, 0x9c, 0xcf, 0x8d, 0xfb, 0x47, 0xab, 0xbb, 36 | 0xe6, 0x56, 0xe1, 0xb8, 0x2f, 0xbc, 0x63, 0x4b, 37 | 0xa4, 0x2c, 0xe1, 0x86, 0xe8, 0xdc, 0x5e, 0x1c, 38 | 0xe0, 0x9a, 0x88, 0x5d, 0x41, 0xf4, 0x34, 0x51]) 39 | digest = BLAKE(512).digest("The quick brown fox jumps over the lazy dog") 40 | assert result == digest 41 | 42 | 43 | def test_BLAKE256_tc1(): 44 | result = bytes([0x0c, 0xe8, 0xd4, 0xef, 0x4d, 0xd7, 0xcd, 0x8d, 45 | 0x62, 0xdf, 0xde, 0xd9, 0xd4, 0xed, 0xb0, 0xa7, 46 | 0x74, 0xae, 0x6a, 0x41, 0x92, 0x9a, 0x74, 0xda, 47 | 0x23, 0x10, 0x9e, 0x8f, 0x11, 0x13, 0x9c, 0x87]) 48 | digest = BLAKE(256).digest(bytes(1)) 49 | assert result == digest 50 | 51 | 52 | def test_BLAKE256_tc2(): 53 | result = bytes([0xd4, 0x19, 0xba, 0xd3, 0x2d, 0x50, 0x4f, 0xb7, 54 | 0xd4, 0x4d, 0x46, 0x0c, 0x42, 0xc5, 0x59, 0x3f, 55 | 0xe5, 0x44, 0xfa, 0x4c, 0x13, 0x5d, 0xec, 0x31, 56 | 0xe2, 0x1b, 0xd9, 0xab, 0xdc, 0xc2, 0x2d, 0x41]) 57 | digest = BLAKE(256).digest(bytes(72)) 58 | assert result == digest 59 | -------------------------------------------------------------------------------- /tests/test_ChaCha.py: -------------------------------------------------------------------------------- 1 | from ChaCha import ChaCha 2 | 3 | 4 | def test_chacha_permute(): 5 | chacha12 = ChaCha(rounds=12) 6 | vector = bytes([0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 7 | 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 8 | 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 9 | 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 10 | 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 11 | 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 12 | 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 13 | 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f]) 14 | result = bytes([0xb3, 0x1a, 0xfb, 0x8e, 0xc3, 0x53, 0x1e, 0x35, 15 | 0x95, 0xb5, 0xd6, 0xff, 0x90, 0x29, 0x36, 0xa5, 16 | 0xf5, 0xb0, 0xaf, 0x5a, 0x32, 0xed, 0x4c, 0xca, 17 | 0xc6, 0xc2, 0x12, 0x04, 0x75, 0xe9, 0x4b, 0xef, 18 | 0x99, 0x15, 0x39, 0xb2, 0x95, 0x93, 0xc6, 0x52, 19 | 0xdf, 0x7f, 0x8e, 0x8f, 0x1d, 0xa7, 0x24, 0x8d, 20 | 0x39, 0x41, 0xb0, 0x23, 0xce, 0x1a, 0x31, 0x10, 21 | 0x35, 0x3e, 0xbc, 0x80, 0x47, 0x2e, 0xab, 0x09]) 22 | assert result == chacha12.permuted(vector) 23 | 24 | 25 | def test_chacha_TCs(): 26 | """Checks test functions for the ChaCha permutation 27 | 28 | This function partially implements the test vectors that have been 29 | specified in the Internet-Draft 'draft-strombergson-chacha-test-vectors-01' 30 | """ 31 | TCs = [{'key': bytes([0xc4, 0x6e, 0xc1, 0xb1, 0x8c, 0xe8, 0xa8, 0x78, 32 | 0x72, 0x5a, 0x37, 0xe7, 0x80, 0xdf, 0xb7, 0x35]), 33 | 'iv': bytes([0x1a, 0xda, 0x31, 0xd5, 0xcf, 0x68, 0x82, 0x21]), 34 | 'state': [0x61707865, 0x3120646e, 35 | 0x79622d36, 0x6b206574, 36 | 0xb1c16ec4, 0x78a8e88c, 37 | 0xe7375a72, 0x35b7df80, 38 | 0xb1c16ec4, 0x78a8e88c, 39 | 0xe7375a72, 0x35b7df80, 40 | 0x00000000, 0x00000000, 41 | 0xd531da1a, 0x218268cf], 42 | 'stream': [bytes([0xb0, 0x2b, 0xd8, 0x1e, 0xb5, 0x5c, 0x8f, 0x68, 43 | 0xb5, 0xe9, 0xca, 0x4e, 0x30, 0x70, 0x79, 0xbc, 44 | 0x22, 0x5b, 0xd2, 0x20, 0x07, 0xed, 0xdc, 0x67, 45 | 0x02, 0x80, 0x18, 0x20, 0x70, 0x9c, 0xe0, 0x98, 46 | 0x07, 0x04, 0x6a, 0x0d, 0x2a, 0xa5, 0x52, 0xbf, 47 | 0xdb, 0xb4, 0x94, 0x66, 0x17, 0x6d, 0x56, 0xe3, 48 | 0x2d, 0x51, 0x9e, 0x10, 0xf5, 0xad, 0x5f, 0x27, 49 | 0x46, 0xe2, 0x41, 0xe0, 0x9b, 0xdf, 0x99, 0x59]), 50 | bytes([0x17, 0xbe, 0x08, 0x73, 0xed, 0xde, 0x9a, 0xf5, 51 | 0xb8, 0x62, 0x46, 0x44, 0x1c, 0xe4, 0x10, 0x19, 52 | 0x5b, 0xae, 0xde, 0x41, 0xf8, 0xbd, 0xab, 0x6a, 53 | 0xd2, 0x53, 0x22, 0x63, 0x82, 0xee, 0x38, 0x3e, 54 | 0x34, 0x72, 0xf9, 0x45, 0xa5, 0xe6, 0xbd, 0x62, 55 | 0x8c, 0x7a, 0x58, 0x2b, 0xcf, 0x8f, 0x89, 0x98, 56 | 0x70, 0x59, 0x6a, 0x58, 0xda, 0xb8, 0x3b, 0x51, 57 | 0xa5, 0x0c, 0x7d, 0xbb, 0x4f, 0x3e, 0x6e, 0x76]) 58 | ], 59 | 'rounds': 12, 60 | }, 61 | ] 62 | for tc in TCs: 63 | chacha = ChaCha(tc['key'], tc['iv'], tc['rounds']) 64 | assert tc['state'] == chacha.state 65 | assert all(block == chacha.keystream() for block in tc['stream']) 66 | 67 | 68 | def test_streamblocks(): 69 | chacha = ChaCha() 70 | stream1024 = b''.join([chacha.keystream(64) for _ in range(16)]) 71 | assert ChaCha().keystream(1024) == stream1024 72 | 73 | 74 | def test_halfblock(): 75 | assert ChaCha().keystream(37) == ChaCha().keystream(64)[:37] 76 | -------------------------------------------------------------------------------- /tests/test_HORST.py: -------------------------------------------------------------------------------- 1 | import os 2 | from HORST import HORST 3 | from SPHINCS import SPHINCS 4 | 5 | 6 | def test_horst(): 7 | n = 256 8 | m = 512 9 | tau = 8 # smaller than actual SPHINCS-256, for fast testing 10 | M = os.urandom(m // 8) 11 | seed = os.urandom(n // 8) 12 | masks = [os.urandom(n // 8) for _ in range(2*tau)] 13 | horst = HORST(n=n, m=m, k=m // tau, tau=tau, 14 | F=SPHINCS().F, H=SPHINCS().H, Gt=SPHINCS().Glambda) 15 | pk = horst.keygen(seed, masks) 16 | sig, pk_sig = horst.sign(M, seed, masks) 17 | assert pk == horst.verify(M, sig, masks) 18 | assert pk == pk_sig 19 | 20 | 21 | def test_message_indices(): 22 | n = 256 23 | m = 512 24 | tau = 16 25 | horst = HORST(n=n, m=m, k=m // tau, tau=tau, 26 | F=SPHINCS().F, H=SPHINCS().H, Gt=SPHINCS().Glambda) 27 | assert all(x == 257 for x in horst.message_indices(bytes([1] * (m // 8)))) 28 | incr = horst.message_indices(bytes(range(m // 8))) 29 | assert incr == [256, 770, 1284, 1798, 2312, 2826, 3340, 3854, 30 | 4368, 4882, 5396, 5910, 6424, 6938, 7452, 7966, 31 | 8480, 8994, 9508, 10022, 10536, 11050, 11564, 12078, 32 | 12592, 13106, 13620, 14134, 14648, 15162, 15676, 16190] 33 | 34 | 35 | def test_horst_ref(): 36 | n = 256 37 | m = 512 38 | tau = 16 39 | M = bytes(range(m // 8)) 40 | seed = bytes(range(64, 96)) 41 | masks = [bytes(range(i, 32+i)) for i in range(2*tau)] 42 | horst = HORST(n=n, m=m, k=m / tau, tau=tau, 43 | F=SPHINCS().F, H=SPHINCS().H, Gt=SPHINCS().Glambda) 44 | sig, pk = horst.sign(M, seed, masks) 45 | assert pk == horst.verify(M, sig, masks) 46 | # swap sigma_k to the start to match SPHINCS reference implementation 47 | sig = [sig[-1]] + sig[:-1] 48 | assert sig == [[bytes([0x5b, 0xe1, 0x99, 0x61, 0xbf, 0xe8, 0x2f, 0x66, 49 | 0x13, 0x5e, 0x33, 0x93, 0xf8, 0xba, 0x02, 0x83, 50 | 0x42, 0xe1, 0x92, 0xaa, 0x62, 0xb8, 0x46, 0xf0, 51 | 0x08, 0x8e, 0x7d, 0x9b, 0x8d, 0xaf, 0x06, 0x35]), 52 | bytes([0xd9, 0xc1, 0xaf, 0x14, 0x50, 0x9c, 0x01, 0xf3, 53 | 0xcc, 0x03, 0xcf, 0x31, 0x4b, 0xdf, 0x64, 0xf7, 54 | 0xb0, 0x29, 0x82, 0x14, 0xee, 0xdd, 0x6f, 0x2f, 55 | 0x9c, 0x5b, 0x88, 0xa4, 0x1a, 0xff, 0x87, 0x3c]), 56 | bytes([0x9f, 0x49, 0x5a, 0x7c, 0x88, 0x62, 0x2d, 0xbd, 57 | 0xd0, 0xe9, 0x29, 0xcf, 0x8e, 0x93, 0x24, 0xbc, 58 | 0x66, 0x96, 0x8f, 0x9a, 0x3e, 0x31, 0xd5, 0x9c, 59 | 0xa5, 0xbc, 0x2f, 0x96, 0x7e, 0xfb, 0x96, 0xd1]), 60 | bytes([0x1c, 0xf9, 0x9f, 0x83, 0x38, 0x1b, 0x9e, 0xbf, 61 | 0x14, 0x62, 0xb5, 0x72, 0x45, 0x35, 0xb6, 0x07, 62 | 0x66, 0x93, 0x02, 0x0b, 0xae, 0xaa, 0xeb, 0x8d, 63 | 0x7f, 0xee, 0xa6, 0x98, 0x7a, 0x30, 0x11, 0x32]), 64 | bytes([0xe2, 0x46, 0xb5, 0x6d, 0xe0, 0x36, 0x4d, 0xd9, 65 | 0x1c, 0x97, 0x16, 0x50, 0xdf, 0xf2, 0x2b, 0x0b, 66 | 0x18, 0x03, 0x8a, 0x09, 0x3c, 0x80, 0xf8, 0xfe, 67 | 0xa9, 0xd2, 0x74, 0x94, 0xa3, 0x86, 0xdf, 0xa4]), 68 | bytes([0xa3, 0xb8, 0x05, 0x8c, 0x3c, 0x61, 0x13, 0xe1, 69 | 0xf4, 0x6f, 0xe0, 0xe6, 0x48, 0x16, 0x5b, 0xe0, 70 | 0x41, 0xf0, 0x22, 0x6a, 0xf8, 0x18, 0x8d, 0x08, 71 | 0x96, 0xb2, 0xc2, 0xe7, 0xf6, 0xeb, 0x55, 0x95]), 72 | bytes([0x62, 0x21, 0xa0, 0x4f, 0x66, 0x1f, 0x25, 0x69, 73 | 0x4c, 0xcf, 0x91, 0x52, 0x7a, 0x17, 0xf9, 0x9e, 74 | 0xf7, 0x94, 0x79, 0x0c, 0x2c, 0xd6, 0x73, 0x8e, 75 | 0x80, 0xd0, 0xa1, 0xf3, 0x03, 0x37, 0x06, 0x40]), 76 | bytes([0xfe, 0xc8, 0x70, 0xe2, 0xd7, 0x99, 0xed, 0x24, 77 | 0x47, 0x5a, 0x80, 0x6b, 0xeb, 0x0c, 0xfd, 0x33, 78 | 0xa0, 0x37, 0x90, 0xc0, 0x44, 0xc5, 0x3a, 0xff, 79 | 0x33, 0x5c, 0x35, 0xfa, 0x27, 0xe2, 0x8e, 0xdb]), 80 | bytes([0x82, 0xd6, 0x66, 0xd3, 0xab, 0x22, 0x50, 0xcc, 81 | 0x2a, 0x5f, 0x5b, 0x46, 0xfc, 0x75, 0x20, 0x58, 82 | 0xfa, 0xcd, 0x95, 0x8c, 0x35, 0x96, 0xd5, 0xde, 83 | 0x3d, 0xf0, 0x5e, 0x45, 0x69, 0x62, 0xad, 0x84]), 84 | bytes([0x53, 0x17, 0xd4, 0x71, 0xb0, 0x75, 0xba, 0xdc, 85 | 0x2f, 0x45, 0xc9, 0xf3, 0x69, 0x76, 0xc6, 0xfd, 86 | 0x75, 0x4b, 0xc4, 0x0c, 0x15, 0x64, 0x03, 0xa6, 87 | 0x3f, 0x80, 0xfd, 0xd3, 0x1a, 0x7c, 0x43, 0xf7]), 88 | bytes([0xc7, 0xb1, 0xb6, 0x39, 0xd6, 0x66, 0x67, 0x91, 89 | 0xee, 0x7f, 0x69, 0xee, 0xd1, 0xa6, 0x54, 0xf9, 90 | 0xd3, 0x66, 0x9e, 0xaf, 0x59, 0xf6, 0x9d, 0xb6, 91 | 0x7e, 0x42, 0xba, 0x23, 0xf7, 0x86, 0x58, 0xae]), 92 | bytes([0x7f, 0xb9, 0x9b, 0x00, 0x39, 0x76, 0x62, 0xa1, 93 | 0x13, 0xf2, 0xe4, 0x23, 0xb3, 0xbe, 0xe2, 0x26, 94 | 0x9a, 0x66, 0x1f, 0x66, 0x20, 0xc0, 0x59, 0x14, 95 | 0xf9, 0x49, 0x1c, 0xb5, 0xa0, 0x4b, 0x4d, 0xe5]), 96 | bytes([0xf8, 0x8b, 0xe5, 0x2b, 0x0b, 0xa6, 0x67, 0x73, 97 | 0xb4, 0x54, 0xba, 0x80, 0xfc, 0x33, 0xb3, 0x98, 98 | 0xda, 0x72, 0xd5, 0x50, 0x5d, 0xf4, 0x65, 0x45, 99 | 0x7a, 0x5a, 0x3a, 0x03, 0xfa, 0x59, 0xc4, 0x95]), 100 | bytes([0x84, 0x80, 0xcd, 0xbb, 0xa9, 0xef, 0x24, 0x47, 101 | 0x7d, 0xaf, 0xbf, 0xc5, 0xff, 0xe6, 0x9d, 0x7a, 102 | 0x39, 0x59, 0xfb, 0x66, 0x56, 0xa9, 0x45, 0x65, 103 | 0xc8, 0xf2, 0xea, 0xad, 0x99, 0xa2, 0xdb, 0x28]), 104 | bytes([0xcf, 0x71, 0x2b, 0xa6, 0xda, 0x23, 0x4f, 0x0c, 105 | 0x09, 0xc1, 0x27, 0x0f, 0x7d, 0xac, 0xdb, 0x16, 106 | 0x19, 0xc7, 0x6a, 0x2b, 0x44, 0x30, 0x77, 0xc4, 107 | 0x72, 0x0d, 0x90, 0x26, 0x70, 0x15, 0x85, 0x04]), 108 | bytes([0x21, 0xab, 0xf8, 0x56, 0x2e, 0x42, 0xc7, 0xd8, 109 | 0x36, 0x9e, 0xf8, 0x06, 0x7d, 0x40, 0xcb, 0x12, 110 | 0x0e, 0xc7, 0x7f, 0x47, 0x29, 0x63, 0xbf, 0xc2, 111 | 0x86, 0x95, 0x4a, 0xe0, 0xb5, 0x84, 0xcc, 0x5b]), 112 | bytes([0xc6, 0x09, 0x29, 0x10, 0x58, 0xc7, 0xd5, 0x80, 113 | 0x68, 0x90, 0xcc, 0xc0, 0x69, 0x8d, 0x15, 0x56, 114 | 0x7e, 0x1c, 0xfb, 0x02, 0x33, 0x38, 0xa6, 0x2f, 115 | 0xc1, 0xea, 0x9c, 0x7a, 0x11, 0x8b, 0xc9, 0x6f]), 116 | bytes([0x27, 0xe4, 0xf3, 0xac, 0xad, 0x81, 0xe5, 0xe3, 117 | 0xd7, 0x04, 0x9a, 0xf7, 0x0a, 0xf7, 0x30, 0x33, 118 | 0xe3, 0x18, 0x4b, 0x9d, 0xbd, 0x38, 0x62, 0x7d, 119 | 0xb5, 0x2d, 0xa8, 0xed, 0x2a, 0x86, 0x47, 0x16]), 120 | bytes([0x75, 0x98, 0x32, 0x64, 0x04, 0x25, 0xf9, 0x58, 121 | 0x77, 0x27, 0xae, 0x5c, 0xf5, 0x4c, 0x3a, 0x81, 122 | 0xd6, 0xdc, 0x3d, 0x8f, 0x47, 0xe1, 0x52, 0x2d, 123 | 0xfe, 0x36, 0xff, 0x1a, 0x2c, 0x6b, 0x2a, 0xdd]), 124 | bytes([0xa9, 0xb0, 0xe3, 0xa6, 0xe1, 0xdd, 0x1a, 0xca, 125 | 0xde, 0xa7, 0xb2, 0x7e, 0x28, 0x4d, 0x1a, 0x9c, 126 | 0xa4, 0xe7, 0x70, 0x87, 0xa6, 0x2d, 0x1f, 0xcf, 127 | 0x1d, 0x11, 0x5d, 0xe6, 0xf6, 0xce, 0x2f, 0xd8]), 128 | bytes([0x85, 0x8f, 0x40, 0x01, 0xf7, 0xb6, 0x3d, 0x3d, 129 | 0xea, 0xd6, 0x02, 0x77, 0x43, 0x3d, 0xb0, 0xe2, 130 | 0x76, 0x19, 0xab, 0x96, 0x4b, 0x62, 0xde, 0x33, 131 | 0x60, 0x9e, 0x9f, 0x98, 0xf4, 0x62, 0x94, 0x7e]), 132 | bytes([0x86, 0xbe, 0x89, 0x26, 0xb7, 0xfc, 0x1c, 0x26, 133 | 0x21, 0xd8, 0x28, 0xb1, 0x32, 0xc8, 0x42, 0xe2, 134 | 0x3e, 0x9c, 0xf7, 0x92, 0x09, 0x0f, 0xb3, 0xb2, 135 | 0x2f, 0xc7, 0x36, 0xa1, 0xfb, 0x0c, 0x5f, 0x85]), 136 | bytes([0x87, 0xbe, 0xb1, 0x04, 0x06, 0xc9, 0x92, 0xec, 137 | 0xc5, 0x8d, 0xc2, 0x97, 0x54, 0xcf, 0xac, 0xe5, 138 | 0x06, 0x8b, 0x92, 0x8c, 0x70, 0xf1, 0xa1, 0xc6, 139 | 0x48, 0xb1, 0xa6, 0x31, 0xdc, 0xe6, 0xf9, 0x2b]), 140 | bytes([0x36, 0x12, 0x03, 0x46, 0x93, 0xed, 0xa0, 0xd4, 141 | 0x0a, 0x92, 0xc6, 0x5e, 0xfa, 0x19, 0xfb, 0x71, 142 | 0x3b, 0xbd, 0x4a, 0x57, 0x24, 0xa5, 0x16, 0xa8, 143 | 0x43, 0xfc, 0x5b, 0x2b, 0xf0, 0xc7, 0x2f, 0x81]), 144 | bytes([0x0d, 0x08, 0xbd, 0xd6, 0xda, 0xf2, 0x50, 0xac, 145 | 0x6b, 0xaf, 0x6c, 0x4d, 0x3b, 0xe5, 0x35, 0x8d, 146 | 0xa7, 0x2b, 0xa2, 0xe4, 0xe7, 0x7b, 0x4e, 0x10, 147 | 0xa7, 0xd9, 0x82, 0x57, 0x20, 0x20, 0x00, 0x63]), 148 | bytes([0x52, 0x5b, 0x1a, 0x74, 0x02, 0x77, 0x0f, 0xcb, 149 | 0xa4, 0x59, 0x87, 0x74, 0xab, 0xf3, 0x3b, 0xd9, 150 | 0x7b, 0xdc, 0x30, 0x77, 0x46, 0xc9, 0x06, 0xad, 151 | 0xc0, 0x27, 0xc3, 0x48, 0x8d, 0x8c, 0x73, 0x64]), 152 | bytes([0x70, 0x1f, 0xa0, 0x3a, 0xd7, 0xfd, 0x88, 0x80, 153 | 0x76, 0x1a, 0x56, 0x06, 0x55, 0x8e, 0x6b, 0x11, 154 | 0x06, 0xa9, 0x6f, 0xd7, 0x47, 0xb5, 0x51, 0x13, 155 | 0x96, 0x5e, 0x23, 0x68, 0x11, 0x95, 0xb2, 0x1a]), 156 | bytes([0x02, 0xa8, 0xdd, 0x31, 0xdb, 0xd8, 0x71, 0xd7, 157 | 0xde, 0x76, 0x40, 0x03, 0x82, 0xba, 0xd0, 0x06, 158 | 0x60, 0xcc, 0x55, 0x1b, 0x54, 0xd7, 0x79, 0x30, 159 | 0x35, 0xa4, 0x1c, 0x5d, 0x34, 0xbb, 0x42, 0x4b]), 160 | bytes([0x65, 0xff, 0x3b, 0x19, 0x6a, 0x60, 0xf0, 0x81, 161 | 0x1b, 0xc3, 0x55, 0xab, 0x70, 0x32, 0xb6, 0x40, 162 | 0xe0, 0x1e, 0x9c, 0x93, 0x4c, 0x2f, 0x08, 0x49, 163 | 0xb9, 0x2b, 0x06, 0xf5, 0x2d, 0xbf, 0xa8, 0x83]), 164 | bytes([0x4f, 0x58, 0x27, 0x4e, 0x7b, 0x60, 0x48, 0xb2, 165 | 0x54, 0xdd, 0x10, 0x45, 0xd2, 0xca, 0xdf, 0x2e, 166 | 0x23, 0x44, 0x17, 0xb3, 0x0f, 0xf2, 0x09, 0xad, 167 | 0x45, 0x30, 0xe4, 0x10, 0x90, 0xbe, 0x7e, 0x7b]), 168 | bytes([0xfa, 0xb4, 0x96, 0xb5, 0xb0, 0x4f, 0xd6, 0x5e, 169 | 0x0b, 0xed, 0xde, 0xe9, 0x77, 0xbd, 0x80, 0x28, 170 | 0x77, 0xc8, 0x40, 0x86, 0xe1, 0xa9, 0x67, 0x9f, 171 | 0x39, 0x41, 0x60, 0x21, 0x33, 0x25, 0xb8, 0x32]), 172 | bytes([0x21, 0x81, 0x6c, 0x14, 0xbb, 0x10, 0xde, 0x79, 173 | 0x1f, 0x4d, 0x56, 0xc5, 0xd0, 0x15, 0x93, 0xf5, 174 | 0xb7, 0x1d, 0x8b, 0xe1, 0xf1, 0x53, 0xaf, 0x75, 175 | 0x82, 0x66, 0x16, 0x87, 0xe3, 0x6e, 0x42, 0x09]), 176 | bytes([0xee, 0x97, 0x04, 0x9c, 0x65, 0xef, 0x2b, 0x74, 177 | 0x98, 0x22, 0xf7, 0x48, 0x30, 0xd3, 0xba, 0x6b, 178 | 0x7c, 0x93, 0x3b, 0x1d, 0x6d, 0x09, 0xd2, 0x80, 179 | 0x89, 0xc8, 0x1a, 0xae, 0x79, 0x60, 0xa0, 0x15]), 180 | bytes([0xab, 0x6d, 0x65, 0x92, 0x07, 0x4a, 0x04, 0xdc, 181 | 0x29, 0xc6, 0x1e, 0xc0, 0xdc, 0xc7, 0xb3, 0x41, 182 | 0x1a, 0x6b, 0x4f, 0x76, 0x7f, 0xfe, 0x61, 0x55, 183 | 0x86, 0xf1, 0x9d, 0xef, 0x09, 0xa7, 0xe1, 0xb8]), 184 | bytes([0x28, 0x1e, 0xed, 0x6a, 0xfa, 0xbf, 0x35, 0xe6, 185 | 0x1a, 0x2b, 0xc1, 0xd2, 0xcc, 0x98, 0x15, 0x0d, 186 | 0x73, 0xd6, 0xd1, 0x42, 0x73, 0x93, 0x7f, 0x39, 187 | 0xbc, 0xc3, 0x99, 0x4c, 0x55, 0xc4, 0xc8, 0xe0]), 188 | bytes([0xa4, 0x54, 0x0c, 0x77, 0x71, 0x64, 0x36, 0x44, 189 | 0x43, 0xcb, 0x1a, 0x99, 0xba, 0x6e, 0x96, 0x28, 190 | 0xd6, 0x70, 0x34, 0xcf, 0x08, 0x8d, 0x00, 0x2f, 191 | 0x7a, 0x69, 0xff, 0x2a, 0xdb, 0x23, 0x28, 0x45]), 192 | bytes([0x41, 0xd5, 0x68, 0x18, 0x05, 0x08, 0xc4, 0xe5, 193 | 0xe9, 0x04, 0x02, 0xc0, 0xaa, 0x2b, 0xcc, 0x03, 194 | 0x3a, 0x4f, 0x1a, 0xf3, 0xd2, 0x7b, 0xd3, 0xab, 195 | 0x81, 0xa0, 0x9a, 0x57, 0xcd, 0x79, 0xa2, 0xa4]), 196 | bytes([0x11, 0x88, 0xf6, 0x87, 0x88, 0x10, 0xb8, 0xb1, 197 | 0x80, 0xbf, 0xf6, 0x82, 0x28, 0xbe, 0x59, 0xd6, 198 | 0x13, 0xd0, 0xa2, 0x9c, 0xdb, 0x53, 0x63, 0xc4, 199 | 0x70, 0x41, 0xb3, 0x46, 0x24, 0x13, 0xc5, 0x7e]), 200 | bytes([0x5d, 0xc0, 0x8c, 0x9c, 0x12, 0xd0, 0x0c, 0x9d, 201 | 0x50, 0x3b, 0x1e, 0x05, 0x64, 0x0c, 0xce, 0x64, 202 | 0x61, 0xe8, 0xf7, 0xeb, 0xb2, 0x5e, 0x22, 0x80, 203 | 0x2f, 0xeb, 0xc0, 0xa1, 0x5d, 0xbb, 0x12, 0x56]), 204 | bytes([0x0d, 0x26, 0x5e, 0x94, 0x39, 0x2c, 0x6a, 0x50, 205 | 0x84, 0x10, 0x6f, 0xd8, 0xca, 0xed, 0x47, 0xb7, 206 | 0xfa, 0x05, 0x9c, 0xf1, 0xb5, 0x80, 0xc8, 0xeb, 207 | 0x60, 0x5c, 0xce, 0xc7, 0x86, 0xaf, 0x5a, 0x3f]), 208 | bytes([0x9f, 0x8a, 0x01, 0xc4, 0x91, 0x42, 0x99, 0x93, 209 | 0xd5, 0x11, 0x31, 0xca, 0xad, 0x6f, 0x4e, 0xa2, 210 | 0x9a, 0x86, 0x28, 0xc4, 0x29, 0xb9, 0x2d, 0x45, 211 | 0x3a, 0x04, 0x7a, 0xb2, 0x61, 0xa1, 0xe6, 0xe8]), 212 | bytes([0xe5, 0x3d, 0x75, 0xe8, 0xff, 0x06, 0xff, 0x5c, 213 | 0x0d, 0xe8, 0xf9, 0xbb, 0x8f, 0x18, 0x59, 0x6b, 214 | 0x6b, 0x35, 0x60, 0xe1, 0xed, 0xfc, 0xb9, 0x8e, 215 | 0x08, 0xbb, 0xc2, 0x0c, 0xf1, 0x0c, 0xe1, 0x4b]), 216 | bytes([0x4e, 0xb2, 0x8d, 0xc1, 0xe7, 0x8b, 0x4f, 0x71, 217 | 0xd9, 0x10, 0xab, 0x2d, 0x8e, 0x6e, 0x35, 0xc4, 218 | 0x92, 0x01, 0xb8, 0x44, 0xe5, 0xf9, 0x35, 0x6a, 219 | 0xa2, 0x1d, 0xd4, 0x20, 0x66, 0xca, 0xf2, 0xc6]), 220 | bytes([0xca, 0x24, 0x4a, 0x44, 0x60, 0x6a, 0x08, 0xd5, 221 | 0x13, 0xb5, 0x75, 0xb2, 0xc1, 0x69, 0x87, 0x59, 222 | 0x91, 0x67, 0xc5, 0x87, 0x4f, 0x98, 0x7d, 0x2f, 223 | 0x81, 0x79, 0xa9, 0x83, 0x9f, 0x62, 0x85, 0x46]), 224 | bytes([0xf6, 0xa0, 0x80, 0x3d, 0x80, 0x35, 0x4e, 0x83, 225 | 0xcc, 0xc3, 0xc5, 0xe6, 0x81, 0x39, 0x79, 0xc1, 226 | 0xa2, 0x6c, 0x3c, 0x3a, 0x8d, 0x1d, 0xd5, 0x68, 227 | 0xe2, 0x29, 0xd0, 0x35, 0x3f, 0x45, 0xec, 0xd1]), 228 | bytes([0xd6, 0x10, 0xa5, 0xc8, 0x95, 0xb1, 0x46, 0x02, 229 | 0x74, 0xf6, 0x67, 0xc8, 0x11, 0x38, 0x8a, 0x0b, 230 | 0x79, 0x9e, 0x7a, 0xc1, 0x86, 0xa8, 0x28, 0xdb, 231 | 0x85, 0xbd, 0x83, 0xbb, 0x49, 0x71, 0x38, 0x5a]), 232 | bytes([0xf2, 0xfe, 0xaf, 0x08, 0xe7, 0xd7, 0x57, 0xfd, 233 | 0xb7, 0xa1, 0xb5, 0x98, 0xf7, 0x46, 0x07, 0x96, 234 | 0x08, 0x31, 0xc8, 0x1c, 0x0b, 0x74, 0xe0, 0x35, 235 | 0x5d, 0x06, 0x50, 0xb2, 0xdc, 0x95, 0x17, 0xcc]), 236 | bytes([0x97, 0x13, 0x08, 0x05, 0xd7, 0xfb, 0x23, 0xeb, 237 | 0x08, 0x7b, 0x74, 0x33, 0xcf, 0xe2, 0xe6, 0xfd, 238 | 0xd0, 0x45, 0x11, 0x43, 0x98, 0x66, 0xbb, 0x21, 239 | 0xd9, 0x1c, 0x3d, 0x82, 0x43, 0x51, 0xad, 0x93]), 240 | bytes([0x38, 0x1e, 0xaf, 0x71, 0xa3, 0x55, 0x92, 0xf5, 241 | 0x15, 0x71, 0xc2, 0xf2, 0xd2, 0xd8, 0x55, 0xb0, 242 | 0xfe, 0xa8, 0xaa, 0x1f, 0xf0, 0x70, 0xe3, 0xcc, 243 | 0xb5, 0x8c, 0x48, 0xa6, 0x3e, 0x11, 0xc6, 0xfa]), 244 | bytes([0x25, 0xaf, 0xf8, 0x42, 0xa5, 0xef, 0x95, 0x63, 245 | 0x41, 0x58, 0x1a, 0xba, 0x00, 0x65, 0x47, 0x7b, 246 | 0x27, 0x3e, 0xb1, 0xb9, 0xbf, 0x58, 0x56, 0x48, 247 | 0x6f, 0x0d, 0xec, 0xed, 0x1a, 0x4c, 0xb6, 0xbb]), 248 | bytes([0x1f, 0x9a, 0x45, 0x0b, 0xfc, 0x7e, 0xab, 0xea, 249 | 0x70, 0x7a, 0x17, 0xe3, 0x24, 0xee, 0x7c, 0xc0, 250 | 0xca, 0x3c, 0xa4, 0x25, 0x78, 0x23, 0xc5, 0x38, 251 | 0x9e, 0x25, 0x45, 0x93, 0xc4, 0xda, 0x92, 0x9e]), 252 | bytes([0xbd, 0xb5, 0x33, 0x78, 0x2c, 0xca, 0x61, 0xb0, 253 | 0xb6, 0xcb, 0xed, 0xc8, 0x30, 0x57, 0x1c, 0x47, 254 | 0x6c, 0xfa, 0x45, 0x39, 0x9a, 0x4d, 0xdc, 0x65, 255 | 0xb5, 0xec, 0x3f, 0x4c, 0x24, 0x67, 0xd7, 0x75]), 256 | bytes([0xb2, 0xd1, 0xf1, 0xfc, 0xc5, 0x58, 0xa1, 0xf7, 257 | 0xa8, 0x75, 0x97, 0x60, 0x67, 0xf1, 0x28, 0x75, 258 | 0xeb, 0x3a, 0x84, 0x74, 0x32, 0x23, 0x8d, 0x9d, 259 | 0x03, 0xe9, 0x3c, 0x1f, 0xa5, 0x71, 0x43, 0xb9]), 260 | bytes([0x71, 0x79, 0x2e, 0x1d, 0x55, 0xad, 0xc9, 0x80, 261 | 0x46, 0x97, 0xe8, 0xe9, 0x1c, 0xe7, 0x4c, 0x13, 262 | 0x7f, 0x73, 0xbf, 0x9b, 0xe5, 0x04, 0x08, 0x39, 263 | 0x93, 0x51, 0x30, 0x53, 0x15, 0xfe, 0x93, 0xb5]), 264 | bytes([0xaa, 0x9f, 0x9d, 0xcf, 0xe1, 0xf8, 0xbd, 0x20, 265 | 0x0e, 0x10, 0xda, 0x1e, 0x83, 0xa5, 0x24, 0x48, 266 | 0x67, 0x41, 0xef, 0x48, 0x22, 0x08, 0x2c, 0x23, 267 | 0xba, 0x4c, 0xd7, 0x5c, 0x6c, 0x1f, 0x79, 0xce]), 268 | bytes([0xfe, 0x5f, 0x25, 0xa5, 0x6b, 0xc6, 0xb1, 0x7c, 269 | 0x58, 0x8d, 0x72, 0x4d, 0x5d, 0xcc, 0x67, 0x44, 270 | 0x2d, 0xe8, 0x1c, 0x5e, 0x9b, 0xd6, 0x18, 0xb8, 271 | 0xb9, 0xc7, 0xb1, 0x29, 0xfd, 0x00, 0x61, 0x5c]), 272 | bytes([0xb4, 0x91, 0xd0, 0x91, 0xdc, 0xae, 0x97, 0xd5, 273 | 0xc6, 0xa8, 0x67, 0x2f, 0x8a, 0xb8, 0xcc, 0xfe, 274 | 0x64, 0xa8, 0x9f, 0xa8, 0x17, 0x51, 0x74, 0xae, 275 | 0x43, 0xb4, 0x2c, 0xac, 0x1f, 0xa0, 0xdc, 0xb8]), 276 | bytes([0xc9, 0x0b, 0x8c, 0xd3, 0xa7, 0x93, 0x7a, 0x44, 277 | 0xdb, 0x86, 0x95, 0x6e, 0x24, 0xd3, 0xb0, 0x64, 278 | 0x26, 0x53, 0xd1, 0xdc, 0x8d, 0xba, 0x42, 0x87, 279 | 0xde, 0x44, 0xf6, 0xe6, 0xff, 0x5b, 0xdd, 0xa0]), 280 | bytes([0x33, 0x24, 0x8c, 0xbb, 0xb3, 0x75, 0x77, 0x69, 281 | 0x35, 0xf2, 0x24, 0x6d, 0x53, 0xe6, 0x05, 0x55, 282 | 0x41, 0x2f, 0x71, 0x6e, 0xaa, 0xd4, 0x3e, 0xbd, 283 | 0x3e, 0x03, 0xb4, 0x93, 0x11, 0x04, 0xfe, 0x80]), 284 | bytes([0xe0, 0x94, 0x88, 0x87, 0x5e, 0x07, 0x92, 0x33, 285 | 0x8d, 0xb8, 0xd0, 0xd8, 0xd4, 0x5a, 0x51, 0xdc, 286 | 0xda, 0x87, 0xb8, 0x45, 0xd0, 0xc7, 0xa0, 0x7b, 287 | 0x17, 0x30, 0xef, 0xbe, 0xd5, 0xc5, 0xc8, 0xfc]), 288 | bytes([0x5d, 0xa4, 0x74, 0xe6, 0xcf, 0x25, 0x64, 0xdc, 289 | 0xb7, 0x45, 0x30, 0x71, 0x0b, 0xe1, 0x56, 0xc7, 290 | 0xac, 0x6d, 0x61, 0x41, 0x8b, 0x7b, 0xb0, 0xb2, 291 | 0x0f, 0x93, 0xbf, 0x70, 0x8a, 0xb6, 0xab, 0x79]), 292 | bytes([0xb1, 0xe1, 0xaa, 0xf8, 0x2c, 0xc1, 0x2a, 0xa7, 293 | 0xec, 0x4e, 0xde, 0xef, 0x28, 0x01, 0x7b, 0x5f, 294 | 0x25, 0x44, 0x19, 0x69, 0x2b, 0xda, 0xbc, 0x9d, 295 | 0x1e, 0x6d, 0xfd, 0xfb, 0xf0, 0xe9, 0x7a, 0xaa]), 296 | bytes([0x69, 0xf1, 0xb3, 0x43, 0xe3, 0x2f, 0x15, 0x58, 297 | 0xc0, 0x8b, 0xf1, 0x63, 0xcf, 0x0a, 0x27, 0x64, 298 | 0x85, 0x37, 0xfa, 0xcc, 0x73, 0x18, 0x44, 0x93, 299 | 0xfd, 0x1d, 0x77, 0x44, 0x12, 0xe0, 0x52, 0x2f]), 300 | bytes([0x8f, 0x8f, 0x08, 0x28, 0x1e, 0x10, 0xff, 0x73, 301 | 0xa5, 0x68, 0x92, 0x9a, 0x02, 0x1e, 0x1b, 0x86, 302 | 0x9a, 0x7f, 0x08, 0x95, 0xc5, 0x85, 0x24, 0x9d, 303 | 0x46, 0xe4, 0x4d, 0x15, 0x8c, 0x6d, 0x61, 0x4f]) 304 | ], 305 | (bytes([0x50, 0x7c, 0xa4, 0xc3, 0xde, 0x59, 0x46, 0x16, 306 | 0x10, 0x9f, 0x90, 0x3d, 0xb0, 0xfe, 0xf5, 0xb2, 307 | 0xd9, 0x06, 0x11, 0xb3, 0x90, 0xd4, 0x59, 0x32, 308 | 0xc7, 0x0e, 0x37, 0x61, 0xee, 0x2e, 0xe4, 0x15]), 309 | [bytes([0x76, 0x4d, 0x34, 0x0a, 0xd1, 0xb6, 0xfa, 0x0e, 310 | 0x5b, 0x50, 0x92, 0x1a, 0xd6, 0xa3, 0x92, 0x76, 311 | 0x5f, 0xdc, 0x43, 0xec, 0x15, 0x61, 0xe7, 0x63, 312 | 0x0b, 0xd9, 0xec, 0x86, 0xa5, 0x8e, 0xdf, 0x53]), 313 | bytes([0xcc, 0x0e, 0xf6, 0x74, 0xfa, 0x70, 0xb0, 0xdc, 314 | 0xb2, 0x98, 0x7a, 0x74, 0x8f, 0xac, 0x54, 0xc9, 315 | 0x41, 0xf1, 0x82, 0x88, 0xfa, 0xe2, 0x67, 0x8c, 316 | 0x8a, 0xaf, 0x37, 0x59, 0x1f, 0x25, 0x2f, 0xfd]), 317 | bytes([0x62, 0xd9, 0xd6, 0x88, 0x70, 0xbf, 0xe6, 0x97, 318 | 0x98, 0x49, 0xd1, 0x7c, 0xa6, 0x67, 0x66, 0x46, 319 | 0x88, 0x26, 0xc6, 0xaa, 0xd0, 0xea, 0x17, 0x9f, 320 | 0xe3, 0x04, 0x73, 0xae, 0x98, 0x97, 0x85, 0x38]), 321 | bytes([0xa0, 0x34, 0x07, 0xe8, 0x46, 0xab, 0x34, 0x50, 322 | 0xd0, 0x95, 0x71, 0x11, 0x1c, 0xbd, 0xc6, 0xe0, 323 | 0xb6, 0x67, 0xb3, 0x2e, 0x15, 0x3d, 0xab, 0xd1, 324 | 0x08, 0x76, 0x80, 0xb7, 0x7a, 0xd8, 0xff, 0x4a]), 325 | bytes([0xda, 0xaf, 0x25, 0xbe, 0xa0, 0xbb, 0x4e, 0x77, 326 | 0x69, 0x8b, 0xa6, 0x5b, 0x5c, 0xcf, 0xa8, 0xc1, 327 | 0xa5, 0xf4, 0x94, 0x08, 0x16, 0x5d, 0x32, 0xfb, 328 | 0xfc, 0x1f, 0x37, 0x45, 0x68, 0xbf, 0x4b, 0x0f]), 329 | bytes([0x76, 0x4f, 0x59, 0x34, 0xe5, 0x2f, 0x13, 0xd5, 330 | 0x7e, 0x2a, 0x6a, 0x7d, 0x52, 0x09, 0x9c, 0x10, 331 | 0x45, 0x09, 0xf9, 0x6a, 0xd1, 0x45, 0xc6, 0xfc, 332 | 0x60, 0x0d, 0x0c, 0xa6, 0x86, 0x31, 0x5f, 0x57]), 333 | bytes([0x48, 0xa6, 0x44, 0x4e, 0x05, 0xdc, 0xe9, 0xe8, 334 | 0x24, 0xd7, 0x32, 0x69, 0xcd, 0x91, 0x75, 0x13, 335 | 0xba, 0xb2, 0x36, 0xde, 0xfb, 0x15, 0xd8, 0xb3, 336 | 0x0a, 0x04, 0xab, 0xef, 0x26, 0x6c, 0x33, 0xb7]), 337 | bytes([0x40, 0xa8, 0x99, 0x21, 0x11, 0x2c, 0xe5, 0x7b, 338 | 0x71, 0xd5, 0x40, 0xcb, 0xda, 0xf2, 0x14, 0x70, 339 | 0xa3, 0x23, 0x62, 0x40, 0x92, 0x07, 0x21, 0xd2, 340 | 0xe6, 0x20, 0x4c, 0x2b, 0xd4, 0x3f, 0xac, 0xce]), 341 | bytes([0x56, 0x90, 0xe6, 0x12, 0xd8, 0x54, 0xe3, 0x5c, 342 | 0x09, 0x1a, 0x1a, 0x73, 0x08, 0x3a, 0xa8, 0x33, 343 | 0x80, 0x85, 0x65, 0x0e, 0x84, 0x7a, 0x10, 0x21, 344 | 0x75, 0x71, 0x47, 0xda, 0xf9, 0xed, 0xd5, 0x89]), 345 | bytes([0x1d, 0x60, 0x9c, 0x25, 0x4f, 0xcc, 0xa2, 0xe0, 346 | 0x30, 0x8a, 0xe2, 0x32, 0xe1, 0x4d, 0x5d, 0x53, 347 | 0x17, 0x21, 0x5e, 0x49, 0x43, 0xa7, 0xde, 0x81, 348 | 0x18, 0xa6, 0x8a, 0x6c, 0xf6, 0xae, 0xaa, 0xf8])]), 349 | (bytes([0xfd, 0x07, 0x4c, 0x53, 0x61, 0xa2, 0x5b, 0x1e, 350 | 0x1e, 0x2f, 0x9b, 0xaa, 0x10, 0x12, 0xd0, 0x34, 351 | 0x75, 0x50, 0xa3, 0x73, 0xea, 0x9c, 0x72, 0xb1, 352 | 0x3d, 0xf7, 0xa7, 0x4c, 0x91, 0x67, 0x92, 0x1f]), 353 | [bytes([0x40, 0xe8, 0xe0, 0xa8, 0x05, 0x32, 0x5b, 0xb6, 354 | 0x80, 0xd5, 0x67, 0xfe, 0x0a, 0x1f, 0x3d, 0x31, 355 | 0x34, 0x96, 0xc1, 0xad, 0x13, 0xb0, 0x7d, 0xf2, 356 | 0xa3, 0x13, 0xf6, 0x65, 0xba, 0xa7, 0xf0, 0xc7]), 357 | bytes([0x32, 0xb7, 0x51, 0x9d, 0x27, 0x67, 0xad, 0x75, 358 | 0x60, 0x0c, 0x90, 0x17, 0xec, 0xee, 0xa0, 0x36, 359 | 0x69, 0x1d, 0x7d, 0x79, 0xe5, 0x94, 0xbf, 0xa4, 360 | 0xde, 0x7c, 0x89, 0x2e, 0xa8, 0x81, 0x04, 0xc9]), 361 | bytes([0x8e, 0x5f, 0x68, 0x17, 0xa3, 0x4f, 0x71, 0x3b, 362 | 0xf8, 0xca, 0x84, 0x57, 0xd6, 0xba, 0x5f, 0x4c, 363 | 0x78, 0xc6, 0xe2, 0xc2, 0xbd, 0xb3, 0x6e, 0x48, 364 | 0xe4, 0xae, 0x1c, 0xb7, 0x0c, 0xa0, 0x4b, 0x9e]), 365 | bytes([0x74, 0xb3, 0xe0, 0x30, 0xa8, 0x93, 0x46, 0xfb, 366 | 0x0d, 0xbb, 0x4c, 0xa9, 0x70, 0x83, 0x9e, 0xb1, 367 | 0xde, 0x40, 0x17, 0x2e, 0xe3, 0xba, 0x2c, 0x70, 368 | 0x06, 0xda, 0xa8, 0x95, 0xb6, 0x3a, 0x03, 0x28]), 369 | bytes([0x78, 0xf9, 0xef, 0xdc, 0xd4, 0xc2, 0x66, 0xfa, 370 | 0x73, 0xb2, 0xea, 0xda, 0x85, 0xb3, 0xa2, 0x95, 371 | 0x29, 0x32, 0x9b, 0xd5, 0x57, 0x8e, 0xef, 0x68, 372 | 0x9c, 0x63, 0xb5, 0xbe, 0x4b, 0xd6, 0x3a, 0xec]), 373 | bytes([0x2f, 0xc4, 0x1b, 0x6a, 0x55, 0xd5, 0x90, 0x1d, 374 | 0xfd, 0x32, 0x4f, 0x2f, 0x37, 0x2e, 0x20, 0xb6, 375 | 0xe7, 0x22, 0x59, 0xe9, 0xae, 0x6b, 0x18, 0xca, 376 | 0x8d, 0x4f, 0x07, 0x6b, 0x1d, 0x41, 0x4b, 0x81]), 377 | bytes([0xaf, 0x49, 0x9c, 0x37, 0x9e, 0x6a, 0x80, 0x8c, 378 | 0x77, 0xfa, 0x5b, 0x01, 0x6b, 0x51, 0xad, 0xa3, 379 | 0x6c, 0x7b, 0xa3, 0xd3, 0xbe, 0x9a, 0xad, 0x81, 380 | 0x6a, 0xc1, 0x39, 0x84, 0x5a, 0x1c, 0x02, 0x8e]), 381 | bytes([0xac, 0x08, 0x76, 0x1f, 0xdb, 0xc7, 0x16, 0xd0, 382 | 0x22, 0xb6, 0x20, 0xc6, 0x58, 0x77, 0x06, 0xed, 383 | 0xae, 0x4c, 0x0b, 0x20, 0x88, 0x2e, 0x80, 0xf8, 384 | 0x4b, 0xdd, 0x49, 0xeb, 0x14, 0xbf, 0xe8, 0xc3]), 385 | bytes([0xf9, 0x06, 0x19, 0x7e, 0x5d, 0x17, 0x2d, 0xca, 386 | 0xd3, 0x1e, 0xcb, 0x62, 0x02, 0xfb, 0x78, 0x44, 387 | 0xb2, 0xb2, 0x70, 0x49, 0x42, 0x87, 0x64, 0x7e, 388 | 0xd0, 0x04, 0xa5, 0xbf, 0x87, 0x95, 0xa4, 0x37]), 389 | bytes([0x36, 0x35, 0x5b, 0xca, 0x21, 0xae, 0x02, 0xb5, 390 | 0x25, 0xe6, 0xa3, 0x30, 0x24, 0x2e, 0xe9, 0x66, 391 | 0xfa, 0x63, 0x53, 0xa9, 0xf6, 0x9e, 0x00, 0x31, 392 | 0xd5, 0x6a, 0x8b, 0xff, 0x6e, 0x51, 0xf0, 0x63])]), 393 | (bytes([0x1f, 0x7a, 0x31, 0xc6, 0x6f, 0x85, 0x29, 0x0c, 394 | 0xad, 0x5d, 0x34, 0x65, 0x40, 0xb6, 0xa7, 0x18, 395 | 0x93, 0xa6, 0x89, 0x74, 0xf5, 0xd9, 0xb6, 0xd4, 396 | 0xa4, 0xec, 0x18, 0x25, 0x57, 0x73, 0x42, 0x27]), 397 | [bytes([0xa3, 0xe6, 0xdb, 0x92, 0xd7, 0xce, 0xc3, 0xba, 398 | 0x52, 0x59, 0x34, 0x99, 0x68, 0xc1, 0xc6, 0x27, 399 | 0x8b, 0xc2, 0x1b, 0x02, 0xb6, 0xb2, 0x08, 0xe3, 400 | 0x2c, 0x8b, 0x50, 0x18, 0x85, 0x0b, 0x28, 0x78]), 401 | bytes([0x52, 0xc0, 0x30, 0x77, 0xef, 0x57, 0x6b, 0xc1, 402 | 0x34, 0xec, 0xdd, 0x4b, 0xe6, 0x2b, 0x7a, 0xe0, 403 | 0x2f, 0x43, 0x6b, 0x30, 0xc7, 0xf2, 0xa0, 0x79, 404 | 0xe1, 0xfc, 0x0c, 0xdc, 0x66, 0x79, 0x2d, 0xc4]), 405 | bytes([0x1b, 0x2c, 0x93, 0xab, 0x67, 0xe9, 0x9f, 0x7c, 406 | 0xf3, 0xb9, 0x1f, 0xe7, 0x21, 0xb7, 0xae, 0x58, 407 | 0x4b, 0x22, 0x69, 0xf4, 0x9b, 0xec, 0x55, 0x1b, 408 | 0xf0, 0x9b, 0x86, 0xd4, 0xe6, 0x59, 0xe2, 0xf3]), 409 | bytes([0x1d, 0x43, 0x1c, 0xdf, 0x40, 0xc7, 0x09, 0xd1, 410 | 0x2f, 0x16, 0xdd, 0xd3, 0xe0, 0xeb, 0x7c, 0x39, 411 | 0xb9, 0x80, 0xed, 0x13, 0x38, 0xa4, 0x9e, 0x9f, 412 | 0x1c, 0x2f, 0xff, 0x5a, 0x83, 0xbc, 0x24, 0xa4]), 413 | bytes([0xf9, 0xda, 0x44, 0x61, 0x70, 0x48, 0x6d, 0x99, 414 | 0xe2, 0x73, 0xb0, 0x83, 0xa1, 0x50, 0x05, 0x60, 415 | 0xff, 0x38, 0x0d, 0xcb, 0x39, 0x6f, 0x5f, 0x32, 416 | 0x7f, 0x07, 0xfe, 0xe0, 0x03, 0x86, 0x80, 0xbe]), 417 | bytes([0xc2, 0xc5, 0x08, 0x5a, 0x77, 0x84, 0x5b, 0xf4, 418 | 0x3b, 0x4e, 0xae, 0xaa, 0x1d, 0x8e, 0x8e, 0xe2, 419 | 0xea, 0x70, 0x84, 0x28, 0xc0, 0x07, 0xc3, 0x18, 420 | 0xb6, 0x16, 0x1a, 0x99, 0x42, 0x94, 0x65, 0xdd]), 421 | bytes([0x53, 0x2d, 0x75, 0x37, 0x51, 0x71, 0x31, 0xc2, 422 | 0xda, 0x97, 0x3c, 0x47, 0x7e, 0xe6, 0xa5, 0xeb, 423 | 0x48, 0x5f, 0x08, 0x89, 0x95, 0x89, 0x53, 0xd5, 424 | 0x0b, 0x69, 0x44, 0xfd, 0x25, 0xb0, 0x76, 0x91]), 425 | bytes([0xb0, 0xde, 0x47, 0x69, 0xd8, 0x64, 0x12, 0x2b, 426 | 0x57, 0x9d, 0xc3, 0x15, 0xe0, 0x0a, 0x13, 0x03, 427 | 0xe0, 0x20, 0x91, 0x7a, 0xf4, 0xea, 0xa6, 0x1b, 428 | 0xcc, 0x05, 0x3f, 0x5c, 0x19, 0x59, 0x24, 0xed]), 429 | bytes([0x5b, 0x36, 0x1e, 0x16, 0xf2, 0x6d, 0x6c, 0x78, 430 | 0x29, 0x44, 0x6f, 0xa2, 0x1d, 0x1e, 0x8c, 0xd3, 431 | 0x6f, 0x32, 0x62, 0x82, 0x62, 0x19, 0x72, 0x43, 432 | 0x19, 0x19, 0x90, 0x1b, 0xfc, 0xe9, 0xc7, 0x62]), 433 | bytes([0x04, 0xcf, 0xe1, 0xe7, 0xd6, 0x92, 0x73, 0x4b, 434 | 0xee, 0x2e, 0x4c, 0xf5, 0x0c, 0xcb, 0x13, 0xaa, 435 | 0xa9, 0x08, 0x81, 0x8a, 0x3a, 0x77, 0x37, 0x7a, 436 | 0xb8, 0x2f, 0x17, 0xd1, 0x5c, 0xa4, 0x23, 0x86])]), 437 | (bytes([0x7c, 0x79, 0xff, 0x56, 0x26, 0x28, 0x7e, 0x59, 438 | 0xd8, 0xef, 0x74, 0x57, 0x91, 0x2a, 0xfa, 0xd4, 439 | 0xd0, 0x89, 0x8c, 0x25, 0x84, 0xe4, 0x18, 0x6e, 440 | 0x7d, 0x2d, 0x74, 0x5c, 0xe9, 0x0a, 0xa8, 0xb1]), 441 | [bytes([0x32, 0x3c, 0x2e, 0x90, 0xd3, 0x9a, 0xd1, 0x8b, 442 | 0xa8, 0x25, 0x77, 0xa0, 0x9b, 0xb6, 0xe7, 0x70, 443 | 0x73, 0x7f, 0xe1, 0xec, 0x16, 0x23, 0x14, 0xb0, 444 | 0xc8, 0x0a, 0xdf, 0xb6, 0x0e, 0x0d, 0x71, 0xf8]), 445 | bytes([0x7d, 0x45, 0xf8, 0x25, 0x1d, 0x37, 0xe9, 0x93, 446 | 0x98, 0x6f, 0x75, 0x43, 0x84, 0x5a, 0x37, 0x07, 447 | 0xba, 0xcb, 0x28, 0x41, 0x4c, 0xfd, 0x14, 0xa1, 448 | 0xb4, 0x66, 0x30, 0x60, 0x09, 0xf8, 0x9b, 0xc4]), 449 | bytes([0xb7, 0xfb, 0xc6, 0x26, 0x60, 0x5c, 0x08, 0xdb, 450 | 0x89, 0x9f, 0x6a, 0x42, 0xe1, 0x50, 0x61, 0x26, 451 | 0x03, 0x61, 0x6a, 0x8a, 0x66, 0xf4, 0xa1, 0xd3, 452 | 0x9b, 0x45, 0x02, 0x21, 0x3d, 0x62, 0x65, 0x2d]), 453 | bytes([0x25, 0x06, 0x9e, 0x51, 0x41, 0x4e, 0x1f, 0x07, 454 | 0xc7, 0x77, 0xf6, 0x75, 0xf4, 0xc1, 0x4a, 0x8c, 455 | 0xf4, 0xe6, 0x7f, 0xa1, 0x8d, 0xc0, 0xe3, 0x8f, 456 | 0xae, 0x63, 0xab, 0x36, 0xb2, 0x64, 0xeb, 0x86]), 457 | bytes([0x67, 0x73, 0xcd, 0x45, 0x27, 0x01, 0x38, 0xd3, 458 | 0x4d, 0x23, 0x8d, 0x58, 0x45, 0x00, 0xf9, 0xb7, 459 | 0xc8, 0xe3, 0xd1, 0xa8, 0x96, 0x0d, 0xde, 0xdc, 460 | 0x6c, 0x84, 0xe4, 0x57, 0xae, 0x77, 0x03, 0x37]), 461 | bytes([0x2b, 0x36, 0x88, 0xe6, 0x4d, 0x4e, 0xce, 0x23, 462 | 0x03, 0x71, 0x4c, 0x66, 0x4d, 0x3a, 0xb1, 0xde, 463 | 0x5b, 0x06, 0x61, 0x68, 0xca, 0xaf, 0xa7, 0x61, 464 | 0x40, 0x2a, 0x3d, 0x52, 0x5b, 0x18, 0xa5, 0xf8]), 465 | bytes([0x4e, 0x6e, 0xe4, 0x9e, 0xa8, 0x7c, 0x3b, 0xfa, 466 | 0x24, 0x71, 0x77, 0xdc, 0x1a, 0x85, 0xdf, 0xac, 467 | 0xfd, 0x15, 0x8e, 0xa0, 0x8d, 0x96, 0x0f, 0xb2, 468 | 0xac, 0x3b, 0xa3, 0xc4, 0xc3, 0x96, 0x41, 0xcd]), 469 | bytes([0x23, 0xf0, 0x21, 0x8a, 0x41, 0x43, 0x32, 0x00, 470 | 0xaf, 0x11, 0x36, 0x0b, 0xc7, 0x84, 0x48, 0xee, 471 | 0xd1, 0x0a, 0x5b, 0xe2, 0x85, 0xef, 0x96, 0x4b, 472 | 0x6d, 0xf4, 0xdc, 0x0f, 0xea, 0x3c, 0x35, 0xe2]), 473 | bytes([0x44, 0x76, 0x06, 0xeb, 0xb5, 0x28, 0xc7, 0x01, 474 | 0xa0, 0xc4, 0x8d, 0x5e, 0x92, 0xc2, 0x00, 0xa1, 475 | 0xa0, 0x63, 0xf1, 0x02, 0xbc, 0x24, 0x81, 0xa7, 476 | 0x54, 0x00, 0x06, 0x80, 0x50, 0x72, 0xce, 0xc4]), 477 | bytes([0x00, 0x28, 0xe9, 0x78, 0x32, 0x38, 0xbb, 0x2f, 478 | 0x03, 0xf1, 0xab, 0x20, 0x3d, 0x83, 0xd7, 0xa2, 479 | 0x0e, 0x23, 0x69, 0x62, 0x37, 0x3f, 0x9a, 0x17, 480 | 0xdd, 0xcc, 0xa1, 0x1c, 0xe7, 0xaa, 0x6a, 0x68])]), 481 | (bytes([0x0d, 0x03, 0x67, 0x63, 0xcf, 0x66, 0x60, 0x0f, 482 | 0xfb, 0xe6, 0x72, 0x07, 0x7c, 0x50, 0x8b, 0x5a, 483 | 0x65, 0xf9, 0xf1, 0x27, 0x7e, 0xc8, 0x0d, 0x73, 484 | 0x9c, 0x4c, 0x02, 0x97, 0x0f, 0xfd, 0x10, 0xd5]), 485 | [bytes([0x3b, 0x81, 0xee, 0xae, 0xaa, 0x85, 0xb6, 0x22, 486 | 0xe0, 0xde, 0xb0, 0xd5, 0x1a, 0xb9, 0xe7, 0x08, 487 | 0x35, 0xcf, 0xb3, 0xb0, 0x1f, 0x3b, 0xba, 0xc2, 488 | 0xe3, 0xce, 0x00, 0xc3, 0x55, 0x0e, 0x3c, 0xdc]), 489 | bytes([0x8d, 0x22, 0xde, 0xb1, 0x27, 0x7b, 0x1a, 0xf4, 490 | 0xa8, 0x1a, 0x1b, 0x89, 0x28, 0x32, 0x35, 0x08, 491 | 0x8c, 0xca, 0x39, 0xd7, 0x49, 0x32, 0xf8, 0x3c, 492 | 0xe9, 0xd4, 0xe4, 0x86, 0x07, 0x25, 0x33, 0xad]), 493 | bytes([0xd6, 0xce, 0x2b, 0x55, 0xdb, 0x28, 0xcc, 0x28, 494 | 0xf1, 0x01, 0xfe, 0x5a, 0x9e, 0xae, 0x4c, 0x35, 495 | 0x27, 0xa9, 0x88, 0x18, 0x2c, 0xa2, 0x6f, 0x59, 496 | 0x23, 0x2f, 0x7a, 0xe4, 0xbd, 0x83, 0x6d, 0x1d]), 497 | bytes([0xe0, 0xd9, 0x56, 0x01, 0x8b, 0x27, 0xc1, 0x9a, 498 | 0x65, 0xd7, 0x38, 0x2e, 0xf2, 0xbe, 0x62, 0xa3, 499 | 0x08, 0xda, 0x5b, 0xec, 0xe9, 0xc2, 0xca, 0x57, 500 | 0x52, 0x3d, 0x14, 0x23, 0x81, 0xf4, 0x73, 0x19]), 501 | bytes([0xae, 0xaf, 0x3f, 0x20, 0xc8, 0x63, 0xbb, 0x97, 502 | 0x6e, 0x75, 0x86, 0x6a, 0x60, 0x87, 0x16, 0xd9, 503 | 0x1e, 0xba, 0x7c, 0xd7, 0xd9, 0x49, 0xc5, 0xfb, 504 | 0x36, 0xa8, 0xe1, 0xf0, 0x75, 0x10, 0x86, 0x19]), 505 | bytes([0x4e, 0x70, 0xb3, 0x76, 0xc7, 0xbe, 0x61, 0x01, 506 | 0x31, 0x2c, 0x5e, 0x00, 0x73, 0x3b, 0xaf, 0xa2, 507 | 0x37, 0x54, 0x99, 0x56, 0x5f, 0xb8, 0x75, 0x49, 508 | 0xca, 0xed, 0x01, 0x1b, 0xb8, 0x14, 0x60, 0xc5]), 509 | bytes([0x38, 0xcc, 0xc7, 0x0a, 0xa4, 0x71, 0x27, 0x09, 510 | 0x37, 0xfe, 0xaa, 0xd7, 0x46, 0xc5, 0x9b, 0x97, 511 | 0xba, 0x74, 0x6d, 0x97, 0x53, 0xf4, 0x0a, 0x74, 512 | 0xcf, 0xac, 0x31, 0xdf, 0x8c, 0xd1, 0xbf, 0x30]), 513 | bytes([0x36, 0x52, 0xee, 0x19, 0xb3, 0xb6, 0xea, 0x77, 514 | 0xff, 0xe7, 0xa2, 0xef, 0x52, 0x54, 0x40, 0x5c, 515 | 0x31, 0x5f, 0x1a, 0x85, 0x18, 0x80, 0xe9, 0x9a, 516 | 0xda, 0x92, 0xd4, 0xed, 0x73, 0xc9, 0x66, 0x9e]), 517 | bytes([0x43, 0xdd, 0xf6, 0xc0, 0x6b, 0xe0, 0x0a, 0x01, 518 | 0x90, 0x25, 0xed, 0xa7, 0x09, 0x93, 0xfa, 0x39, 519 | 0xec, 0xd3, 0x95, 0xae, 0xda, 0x23, 0x17, 0x2a, 520 | 0xda, 0x57, 0x79, 0x6e, 0xf2, 0x64, 0xc2, 0xc9]), 521 | bytes([0x92, 0xf4, 0xd0, 0x3b, 0xdc, 0xf1, 0xdd, 0x22, 522 | 0xd9, 0x21, 0x77, 0xe9, 0xb5, 0x35, 0x92, 0x88, 523 | 0xad, 0xd6, 0xa1, 0xd6, 0xb1, 0x79, 0x6e, 0x23, 524 | 0x33, 0xe5, 0xc5, 0x30, 0xfa, 0x35, 0xde, 0x5c])]), 525 | (bytes([0xab, 0x1d, 0x1e, 0x7f, 0x5c, 0x12, 0x51, 0xb1, 526 | 0xda, 0x20, 0x26, 0xa7, 0x6f, 0xe8, 0x24, 0xaa, 527 | 0x14, 0xb6, 0x7d, 0x82, 0xc9, 0x10, 0xb7, 0xaf, 528 | 0xcd, 0xe2, 0x28, 0xce, 0xdc, 0x37, 0xf7, 0xea]), 529 | [bytes([0x04, 0x35, 0x0a, 0xcb, 0x93, 0x98, 0x0f, 0x49, 530 | 0xac, 0xaf, 0x85, 0x58, 0xa1, 0x7b, 0x5e, 0x6f, 531 | 0x74, 0x7f, 0x44, 0xd3, 0x94, 0x05, 0x48, 0x15, 532 | 0x42, 0x45, 0x37, 0xf2, 0x65, 0x55, 0x28, 0xcb]), 533 | bytes([0x92, 0x37, 0x42, 0x64, 0xed, 0x3b, 0xbc, 0x1f, 534 | 0x16, 0x87, 0xa6, 0x6f, 0x8d, 0x8f, 0x04, 0x31, 535 | 0x64, 0xbc, 0xc1, 0xb4, 0xb1, 0x4f, 0x9a, 0x38, 536 | 0xb6, 0x19, 0x90, 0x01, 0x7e, 0x17, 0xa5, 0x25]), 537 | bytes([0x54, 0x35, 0x8e, 0x3a, 0xb7, 0xa7, 0x48, 0xd0, 538 | 0x26, 0xba, 0xde, 0xa3, 0x48, 0x15, 0x66, 0xb6, 539 | 0x91, 0x60, 0x68, 0xd1, 0x1f, 0x2c, 0xc7, 0xe2, 540 | 0xa6, 0x2d, 0xd8, 0x5d, 0x54, 0x7c, 0xc7, 0x2c]), 541 | bytes([0x99, 0x83, 0xd0, 0xc5, 0xbc, 0x8a, 0x95, 0xc7, 542 | 0xcd, 0x08, 0xe9, 0x49, 0x91, 0x71, 0x56, 0xd1, 543 | 0xbd, 0x5a, 0x90, 0xb2, 0x91, 0x41, 0x2d, 0xc2, 544 | 0xf0, 0x22, 0xac, 0x55, 0x5c, 0x51, 0xae, 0xfc]), 545 | bytes([0xd1, 0xee, 0x15, 0x14, 0x53, 0x37, 0x83, 0xe3, 546 | 0xfa, 0x1f, 0x68, 0xc1, 0xe5, 0x14, 0x78, 0x5f, 547 | 0x4b, 0xec, 0x17, 0x29, 0x86, 0x17, 0x01, 0x8d, 548 | 0x80, 0x3c, 0xb1, 0xfe, 0x17, 0xfa, 0xcc, 0x42]), 549 | bytes([0x31, 0x3e, 0xd0, 0x09, 0x2b, 0x1f, 0xde, 0x10, 550 | 0xa8, 0x9c, 0x16, 0x1a, 0x51, 0xb2, 0xf2, 0xcf, 551 | 0x33, 0x3c, 0x28, 0x0d, 0xb2, 0x15, 0x43, 0xca, 552 | 0x75, 0x7d, 0x7e, 0x44, 0x2f, 0x44, 0xc0, 0x1d]), 553 | bytes([0x59, 0x17, 0x59, 0x1f, 0x3d, 0x61, 0xa1, 0xf5, 554 | 0xa6, 0xee, 0xd9, 0x10, 0x4a, 0xd4, 0x3a, 0x1b, 555 | 0x9f, 0xf7, 0x73, 0xc9, 0x98, 0xf7, 0xe4, 0xcd, 556 | 0x42, 0x72, 0xb6, 0xaf, 0xf0, 0xee, 0x7f, 0x49]), 557 | bytes([0x2d, 0xf9, 0xa8, 0xb0, 0x11, 0xfe, 0xb5, 0x56, 558 | 0x43, 0xed, 0x56, 0xce, 0x52, 0xb7, 0xd5, 0xe7, 559 | 0x83, 0x51, 0x45, 0x95, 0x73, 0x38, 0xe7, 0xea, 560 | 0xe8, 0xc5, 0x77, 0x36, 0xf8, 0xd4, 0xa4, 0xc3]), 561 | bytes([0x02, 0x75, 0x03, 0xac, 0xc4, 0x63, 0xe1, 0x2e, 562 | 0xda, 0x59, 0xb8, 0x0a, 0x28, 0x74, 0x57, 0xe9, 563 | 0xa3, 0x02, 0x42, 0x9c, 0xb5, 0xd9, 0x43, 0x90, 564 | 0x60, 0x21, 0x42, 0x5d, 0x41, 0x30, 0x5f, 0x41]), 565 | bytes([0xeb, 0x51, 0xeb, 0x39, 0xef, 0xb5, 0x98, 0xfa, 566 | 0x71, 0x79, 0x17, 0x86, 0x6c, 0x26, 0x1b, 0xbf, 567 | 0x4e, 0xe1, 0x47, 0x90, 0x02, 0xc5, 0x74, 0x68, 568 | 0x44, 0xe0, 0x93, 0x37, 0x9f, 0xaa, 0x4f, 0x9b])]), 569 | (bytes([0xbd, 0x75, 0x06, 0xaf, 0x19, 0x1e, 0xfe, 0x56, 570 | 0xc1, 0x8c, 0x1d, 0xde, 0xfe, 0x2d, 0x60, 0x63, 571 | 0x94, 0x39, 0xae, 0x08, 0x48, 0xd6, 0x2f, 0x20, 572 | 0x3b, 0x14, 0x22, 0x80, 0xdc, 0x17, 0x4e, 0xb5]), 573 | [bytes([0x22, 0x23, 0xba, 0xd5, 0x8b, 0x22, 0x53, 0x3a, 574 | 0xf2, 0xe5, 0x23, 0x6d, 0x21, 0x37, 0x3f, 0x28, 575 | 0x66, 0x48, 0xc3, 0x5e, 0x3d, 0x0b, 0xcf, 0x7f, 576 | 0xb5, 0xcf, 0x09, 0x8b, 0xd1, 0x3e, 0xb2, 0x89]), 577 | bytes([0x06, 0x15, 0x21, 0x3e, 0x5c, 0x4e, 0x86, 0x46, 578 | 0x9c, 0x82, 0x93, 0x60, 0xca, 0x58, 0x5e, 0x99, 579 | 0x01, 0xd1, 0x96, 0xb3, 0xf2, 0x14, 0x57, 0x2f, 580 | 0xd0, 0x56, 0xd5, 0x18, 0x23, 0xbd, 0x75, 0x6b]), 581 | bytes([0x36, 0x4f, 0xe3, 0x77, 0x29, 0x46, 0x35, 0x8f, 582 | 0x91, 0x46, 0xa4, 0x5d, 0xf1, 0xab, 0xa6, 0xd4, 583 | 0x45, 0x65, 0xee, 0x3c, 0xdc, 0x1a, 0x87, 0xca, 584 | 0xf3, 0x43, 0x9c, 0x28, 0x08, 0x90, 0x79, 0x00]), 585 | bytes([0x24, 0x9e, 0x64, 0x9f, 0xa4, 0xc5, 0x35, 0x1d, 586 | 0xfc, 0x6b, 0x7e, 0x0e, 0xfa, 0xc8, 0x32, 0xc7, 587 | 0x6e, 0xf3, 0x33, 0x30, 0x8a, 0x2d, 0x59, 0x4b, 588 | 0x8c, 0x1a, 0x94, 0x8c, 0x31, 0x77, 0x04, 0xd0]), 589 | bytes([0xe1, 0xaa, 0x73, 0xb2, 0x6e, 0x64, 0x3e, 0xfa, 590 | 0xbb, 0x00, 0x23, 0x2d, 0x80, 0x41, 0xf5, 0x1b, 591 | 0x92, 0x1d, 0x46, 0xc2, 0xe7, 0xd7, 0x0b, 0x47, 592 | 0xef, 0xc5, 0xd8, 0xa0, 0xc6, 0xd5, 0xfa, 0x22]), 593 | bytes([0xeb, 0x31, 0x6e, 0x5d, 0x0d, 0xc7, 0x06, 0x7e, 594 | 0xb8, 0xe9, 0xfc, 0xe6, 0x0d, 0x47, 0x41, 0x1d, 595 | 0x60, 0xbc, 0xcf, 0xa8, 0x17, 0x9b, 0x59, 0x0c, 596 | 0x4c, 0x2d, 0xa9, 0xee, 0x17, 0x15, 0x96, 0xe9]), 597 | bytes([0xe5, 0x30, 0xff, 0xc7, 0x5e, 0xbf, 0x66, 0xb3, 598 | 0xd2, 0xa1, 0xde, 0x2c, 0x3a, 0x8a, 0x39, 0x73, 599 | 0x33, 0x87, 0x4e, 0xea, 0x60, 0xac, 0x9f, 0x02, 600 | 0x17, 0x64, 0x55, 0x66, 0xb0, 0xab, 0x70, 0x8e]), 601 | bytes([0x1b, 0xac, 0x2c, 0xd0, 0xc3, 0x1a, 0xa0, 0x62, 602 | 0xd0, 0xc2, 0xea, 0xfa, 0x6f, 0xf8, 0xdd, 0xeb, 603 | 0xb5, 0xd2, 0xdd, 0x0b, 0x99, 0xd4, 0x41, 0x68, 604 | 0x7c, 0xb8, 0xb2, 0x12, 0x8c, 0x48, 0x0b, 0x7d]), 605 | bytes([0x31, 0xda, 0x7d, 0xe1, 0x31, 0x4c, 0x49, 0xb3, 606 | 0x22, 0x40, 0x7a, 0x0d, 0x4a, 0x82, 0xe7, 0x18, 607 | 0x69, 0xf9, 0xad, 0x2c, 0x99, 0x8a, 0x8f, 0x20, 608 | 0x90, 0xdf, 0x0e, 0x72, 0x98, 0x5e, 0x2b, 0x41]), 609 | bytes([0xe3, 0x5b, 0xd0, 0x64, 0x57, 0x35, 0x5d, 0x5c, 610 | 0x6f, 0x21, 0x1c, 0x8b, 0xbb, 0x60, 0xae, 0x9f, 611 | 0x1d, 0xd8, 0x48, 0xee, 0x90, 0xe0, 0x03, 0xfa, 612 | 0x01, 0x13, 0x00, 0x27, 0x48, 0xd3, 0xdb, 0x11])]), 613 | (bytes([0xdd, 0xbc, 0x5e, 0x8f, 0x91, 0x53, 0x39, 0xed, 614 | 0x05, 0x09, 0x59, 0xaf, 0x1f, 0xc8, 0x47, 0x28, 615 | 0x92, 0xbf, 0x69, 0xfb, 0xcd, 0x18, 0x10, 0xff, 616 | 0x38, 0x57, 0x78, 0x0b, 0x55, 0xa9, 0x8e, 0x40]), 617 | [bytes([0xa0, 0x3e, 0xd7, 0xab, 0x36, 0x7d, 0xa6, 0xa0, 618 | 0x11, 0xa0, 0xb4, 0xf1, 0xd8, 0xa5, 0x55, 0x41, 619 | 0xc9, 0x6a, 0x6e, 0x4f, 0xe5, 0x87, 0x77, 0xa7, 620 | 0x06, 0x9e, 0x0b, 0x1c, 0xf9, 0x8d, 0x5e, 0x13]), 621 | bytes([0xec, 0x57, 0xbc, 0x50, 0x18, 0xd4, 0x62, 0x6a, 622 | 0xf5, 0x53, 0xa2, 0x75, 0x41, 0x8c, 0x6a, 0x5e, 623 | 0x2a, 0xf3, 0x3c, 0x03, 0x3a, 0x71, 0x83, 0x0c, 624 | 0x43, 0x2e, 0xa3, 0x66, 0x6f, 0x8a, 0x64, 0x33]), 625 | bytes([0xde, 0x58, 0xef, 0xcc, 0x41, 0x82, 0xfe, 0x09, 626 | 0x34, 0xdd, 0xb1, 0x52, 0xd7, 0x49, 0xe1, 0xe7, 627 | 0x16, 0x06, 0x94, 0x5b, 0x76, 0x94, 0xa9, 0x6a, 628 | 0x57, 0x31, 0x17, 0xff, 0x46, 0xaa, 0xb0, 0xd6]), 629 | bytes([0x92, 0x88, 0xc4, 0xe4, 0x77, 0xfc, 0x43, 0xee, 630 | 0x14, 0xda, 0x50, 0x73, 0x93, 0xfa, 0xe2, 0xed, 631 | 0x56, 0xf4, 0x0d, 0xa4, 0x3e, 0xa4, 0x03, 0x6f, 632 | 0xfe, 0xec, 0x6b, 0xe3, 0xf7, 0x55, 0x73, 0xd7]), 633 | bytes([0x8e, 0x5d, 0x98, 0xc6, 0x91, 0x79, 0x07, 0x68, 634 | 0xf0, 0x7c, 0xd2, 0x2b, 0x04, 0xce, 0x6f, 0x2d, 635 | 0x3a, 0xa7, 0x19, 0x44, 0xb4, 0x25, 0x9f, 0x3a, 636 | 0xb7, 0x0c, 0x65, 0x8e, 0xb1, 0x42, 0x3b, 0xaa]), 637 | bytes([0xa1, 0xff, 0xef, 0xc6, 0x7d, 0x1b, 0x99, 0x7e, 638 | 0xd4, 0xf7, 0xc8, 0x82, 0xc3, 0x16, 0xb2, 0x6b, 639 | 0x6b, 0x8a, 0x3d, 0x17, 0x33, 0x33, 0xc8, 0x29, 640 | 0x43, 0xdc, 0x1a, 0x6c, 0xc2, 0x56, 0xb6, 0x41]), 641 | bytes([0x65, 0xcc, 0x64, 0x1a, 0x94, 0x4c, 0xec, 0xcd, 642 | 0xb3, 0xb0, 0xf1, 0x99, 0x1e, 0xe9, 0x32, 0x71, 643 | 0x27, 0x73, 0x6b, 0x18, 0xe9, 0xe2, 0xa0, 0xfa, 644 | 0xa9, 0x97, 0xeb, 0x4f, 0x5c, 0xbe, 0xaf, 0x4c]), 645 | bytes([0x70, 0x89, 0xdc, 0xd5, 0x66, 0x74, 0xdb, 0x1c, 646 | 0xc0, 0x98, 0x4c, 0xec, 0x0d, 0x03, 0x2e, 0xcf, 647 | 0x94, 0xd5, 0x93, 0xb1, 0x8b, 0xd0, 0xef, 0x17, 648 | 0xfe, 0xf3, 0xeb, 0x59, 0x3a, 0x49, 0x29, 0xa3]), 649 | bytes([0xff, 0xa5, 0x6b, 0xda, 0x48, 0x94, 0xc7, 0xe8, 650 | 0x76, 0x95, 0xc3, 0x3c, 0x48, 0x0a, 0xf4, 0x0d, 651 | 0x76, 0x84, 0xd8, 0x14, 0xde, 0xe2, 0x1c, 0x6f, 652 | 0x31, 0x20, 0x82, 0xeb, 0x78, 0x14, 0x3c, 0xef]), 653 | bytes([0x87, 0xca, 0x45, 0x14, 0x8e, 0x4c, 0x5f, 0x95, 654 | 0x7a, 0xaa, 0x31, 0x9c, 0x47, 0x5b, 0xa0, 0x83, 655 | 0x8d, 0x8b, 0xa8, 0x79, 0x18, 0x54, 0x15, 0x30, 656 | 0x50, 0x18, 0x99, 0xde, 0x07, 0xba, 0x69, 0xcc])]), 657 | (bytes([0xff, 0xae, 0x88, 0x26, 0xe2, 0x0b, 0xf8, 0x47, 658 | 0x38, 0xd4, 0xab, 0x28, 0xa9, 0xb9, 0x74, 0xb1, 659 | 0x0a, 0x6a, 0xf2, 0x59, 0xf5, 0xd2, 0xa6, 0xc1, 660 | 0x58, 0x3f, 0x21, 0xf7, 0x3a, 0x7a, 0xf6, 0x60]), 661 | [bytes([0xdb, 0x29, 0x58, 0x5f, 0x83, 0x1a, 0xba, 0xe8, 662 | 0xc0, 0x14, 0x86, 0xf1, 0x93, 0x64, 0x54, 0x49, 663 | 0xef, 0xa5, 0xe7, 0x46, 0xda, 0x58, 0xf3, 0xce, 664 | 0xf0, 0xd5, 0x2a, 0xe8, 0x82, 0xfd, 0xcf, 0xe7]), 665 | bytes([0x77, 0x2f, 0xee, 0x2b, 0xa0, 0xb9, 0x8e, 0x0f, 666 | 0x4a, 0x70, 0x2e, 0x28, 0x07, 0x41, 0x86, 0x5d, 667 | 0xd1, 0xe7, 0x61, 0x70, 0x5c, 0x04, 0xa4, 0x14, 668 | 0xaf, 0xfb, 0x7b, 0x00, 0xe6, 0x43, 0x68, 0x8e]), 669 | bytes([0x73, 0x99, 0xed, 0xa9, 0xd0, 0xb9, 0x8b, 0x03, 670 | 0x9f, 0x8b, 0xb7, 0xa3, 0xc9, 0x1a, 0xa3, 0x7f, 671 | 0x38, 0x80, 0x8a, 0xb1, 0x61, 0x6e, 0xb2, 0xa1, 672 | 0x80, 0x12, 0x32, 0xf6, 0xf6, 0xc6, 0xb8, 0x3f]), 673 | bytes([0x4c, 0x9a, 0x6a, 0x9d, 0xf9, 0xa9, 0x12, 0x02, 674 | 0xe4, 0x66, 0x6b, 0x21, 0xdb, 0xb7, 0x25, 0x33, 675 | 0xb2, 0xd2, 0xca, 0xb1, 0xdb, 0x88, 0x57, 0x92, 676 | 0x07, 0xd7, 0xd6, 0x6e, 0x67, 0xe8, 0xf7, 0xbc]), 677 | bytes([0x1b, 0x26, 0x80, 0xa2, 0x07, 0xda, 0x4d, 0xb1, 678 | 0x8a, 0x51, 0x76, 0xcd, 0x56, 0xc3, 0x06, 0xbd, 679 | 0xea, 0x8f, 0x8f, 0xee, 0x51, 0xef, 0xfe, 0xc2, 680 | 0xeb, 0xba, 0x00, 0x56, 0xd7, 0x74, 0x02, 0xda]), 681 | bytes([0x04, 0x7f, 0x2e, 0x6e, 0xd1, 0xa9, 0x47, 0xf6, 682 | 0x4a, 0x4a, 0x2f, 0x21, 0xc6, 0xfd, 0xdf, 0xf6, 683 | 0xbd, 0x8b, 0xa7, 0x74, 0x1e, 0xc9, 0x9e, 0x0c, 684 | 0x5a, 0x38, 0xeb, 0x7f, 0xaf, 0x32, 0xc2, 0xcf]), 685 | bytes([0x32, 0x1f, 0x88, 0x37, 0x86, 0x8a, 0xbd, 0xf4, 686 | 0xfc, 0x82, 0xa0, 0xa8, 0x5f, 0xac, 0x65, 0x29, 687 | 0x61, 0x01, 0x2a, 0x5c, 0x6f, 0xcc, 0xc5, 0x4c, 688 | 0xc7, 0x3c, 0xca, 0x71, 0xde, 0x58, 0x86, 0xb9]), 689 | bytes([0x0b, 0xf5, 0x19, 0x2f, 0xf5, 0x91, 0xc8, 0x66, 690 | 0xa0, 0x60, 0xfc, 0x31, 0xf9, 0x95, 0xf5, 0x44, 691 | 0x60, 0x9e, 0xc0, 0x10, 0xcd, 0xfa, 0x45, 0xc3, 692 | 0xd7, 0xd3, 0x96, 0x1d, 0x89, 0xa6, 0xac, 0x9c]), 693 | bytes([0x88, 0xae, 0xa6, 0xf3, 0x10, 0x35, 0xa9, 0x02, 694 | 0x93, 0x6c, 0xf7, 0x1e, 0xa1, 0xb0, 0xd7, 0x57, 695 | 0xa4, 0x6e, 0xb3, 0xd6, 0xba, 0xd5, 0x76, 0x29, 696 | 0x1e, 0x50, 0xe3, 0xb2, 0x2e, 0x93, 0x35, 0x32]), 697 | bytes([0x43, 0x66, 0x4d, 0x7a, 0xa6, 0x11, 0x6c, 0xac, 698 | 0x3f, 0x15, 0x1f, 0xc8, 0xcf, 0x71, 0xd5, 0x3c, 699 | 0x83, 0x16, 0x1f, 0xfc, 0x6f, 0x35, 0x53, 0x29, 700 | 0x84, 0xbb, 0xa8, 0x0c, 0x0f, 0x1b, 0x02, 0x75])]), 701 | (bytes([0x4c, 0x92, 0xce, 0x3d, 0x52, 0x36, 0xff, 0x69, 702 | 0xb8, 0x31, 0xf3, 0x52, 0x0e, 0xa8, 0xc5, 0x46, 703 | 0x9c, 0xe4, 0xf3, 0x47, 0xb6, 0xe4, 0xeb, 0x68, 704 | 0x18, 0xb6, 0xe4, 0xd1, 0xe3, 0x31, 0x6c, 0x71]), 705 | [bytes([0xf4, 0x67, 0xf6, 0x61, 0x56, 0xdb, 0x4e, 0x79, 706 | 0x88, 0x35, 0x32, 0x42, 0xf9, 0x52, 0x81, 0xc2, 707 | 0xe5, 0x6b, 0x2f, 0xf2, 0x99, 0x5f, 0xc8, 0x6e, 708 | 0x12, 0x00, 0xe1, 0xa4, 0x14, 0x93, 0xf2, 0x27]), 709 | bytes([0xb3, 0x03, 0xa1, 0x7c, 0x4c, 0x7b, 0xc1, 0x92, 710 | 0xba, 0x8a, 0xd7, 0x5b, 0x4d, 0x45, 0x6a, 0x70, 711 | 0xd6, 0x96, 0x80, 0x87, 0x03, 0x3a, 0x0e, 0x9f, 712 | 0x6d, 0xd9, 0x96, 0xc0, 0x40, 0x5f, 0x5a, 0xbe]), 713 | bytes([0xeb, 0x6d, 0xc6, 0xb0, 0xbc, 0x24, 0xa7, 0x34, 714 | 0xad, 0x29, 0x33, 0x11, 0x5e, 0x5c, 0x08, 0xdf, 715 | 0x14, 0xa6, 0x66, 0x41, 0xef, 0x44, 0x6b, 0x95, 716 | 0x76, 0xd8, 0x43, 0x46, 0x2c, 0x8e, 0x98, 0xa0]), 717 | bytes([0x65, 0x8e, 0x44, 0x83, 0x8d, 0xa0, 0x98, 0xee, 718 | 0xfd, 0xab, 0xf6, 0x0d, 0xd2, 0x3e, 0x74, 0x96, 719 | 0xca, 0x80, 0x21, 0x2d, 0x74, 0x0c, 0x65, 0x2a, 720 | 0xcb, 0x82, 0x59, 0x0f, 0xd7, 0x95, 0x12, 0x55]), 721 | bytes([0xdb, 0xc7, 0x92, 0x66, 0xbe, 0xbc, 0x42, 0x64, 722 | 0x6f, 0x42, 0x51, 0x17, 0x8f, 0xc8, 0xbe, 0x12, 723 | 0xd9, 0x20, 0x1e, 0xf9, 0x77, 0x78, 0x4b, 0x46, 724 | 0x80, 0x90, 0x1a, 0x09, 0x11, 0x82, 0x15, 0xb9]), 725 | bytes([0x38, 0x8c, 0xea, 0x0d, 0x0c, 0x34, 0x51, 0xd3, 726 | 0xc9, 0xff, 0xe5, 0x31, 0x03, 0x76, 0xcd, 0xb1, 727 | 0x25, 0x9c, 0xa8, 0x9e, 0x27, 0xa7, 0xee, 0xfe, 728 | 0x7a, 0xdf, 0x8a, 0x64, 0xf7, 0x9b, 0x68, 0xe2]), 729 | bytes([0xf5, 0xb5, 0xe2, 0x0c, 0x64, 0x80, 0xa9, 0xd5, 730 | 0x39, 0xd5, 0x8d, 0x95, 0xf7, 0x3f, 0xdc, 0xd0, 731 | 0xcb, 0xe3, 0x15, 0xe7, 0x12, 0x47, 0x6c, 0x54, 732 | 0x04, 0xc2, 0x7c, 0x51, 0x33, 0x14, 0x53, 0x17]), 733 | bytes([0x69, 0x97, 0xe4, 0x97, 0x17, 0x16, 0x79, 0x2e, 734 | 0x78, 0x6c, 0xc7, 0xdd, 0x5b, 0x30, 0xcb, 0x86, 735 | 0x03, 0x78, 0x7b, 0x9a, 0x64, 0x9c, 0xb7, 0xed, 736 | 0x72, 0xc1, 0xc9, 0xfa, 0xc3, 0x68, 0x4c, 0x58]), 737 | bytes([0x71, 0x28, 0x37, 0xe2, 0xe8, 0x41, 0xf8, 0xcb, 738 | 0xeb, 0x49, 0x38, 0x8b, 0x69, 0xfb, 0xf1, 0x7c, 739 | 0xbe, 0x20, 0x4f, 0x5a, 0xb2, 0x56, 0xfd, 0xdc, 740 | 0x1c, 0x4d, 0x20, 0x81, 0xc9, 0x81, 0x17, 0xbc]), 741 | bytes([0x88, 0x59, 0x49, 0x93, 0x09, 0x69, 0x4a, 0xeb, 742 | 0xd3, 0x53, 0xf7, 0x4d, 0x80, 0xd5, 0x36, 0x36, 743 | 0xb3, 0xd3, 0x93, 0x0a, 0x6d, 0xcd, 0x40, 0xca, 744 | 0xc0, 0x49, 0xed, 0x3e, 0x22, 0xfe, 0x78, 0xf4])]), 745 | (bytes([0x7d, 0x5f, 0x23, 0xd4, 0xfb, 0xc6, 0x6a, 0xb0, 746 | 0x6b, 0x65, 0xd0, 0x94, 0x4d, 0x4a, 0x49, 0x25, 747 | 0x60, 0x50, 0x4f, 0x96, 0xd9, 0x0f, 0xd1, 0xc0, 748 | 0xab, 0xbd, 0xa4, 0x14, 0x40, 0x3f, 0x31, 0x26]), 749 | [bytes([0xb6, 0xa2, 0x9c, 0x2b, 0x98, 0x65, 0x03, 0xb1, 750 | 0x80, 0x4b, 0xd3, 0xe7, 0x69, 0x5c, 0x1b, 0x29, 751 | 0xe4, 0x31, 0xe0, 0xcc, 0x09, 0x99, 0xa8, 0xf6, 752 | 0x89, 0xbb, 0x44, 0x2c, 0x3b, 0x29, 0xf5, 0x8a]), 753 | bytes([0x5c, 0x43, 0x2b, 0x89, 0xf5, 0xa6, 0xc2, 0xca, 754 | 0x2b, 0x5b, 0xb8, 0xf2, 0xaa, 0xb1, 0x3b, 0x75, 755 | 0x05, 0xd1, 0xac, 0xd4, 0xe4, 0xc9, 0xe8, 0xce, 756 | 0x7e, 0x40, 0xbf, 0xce, 0xbd, 0xf1, 0x6d, 0x35]), 757 | bytes([0x7c, 0x7d, 0x79, 0xea, 0xa0, 0xac, 0xe4, 0xba, 758 | 0x58, 0x31, 0x0a, 0xfd, 0x88, 0x8c, 0xaa, 0x8a, 759 | 0x62, 0xcc, 0xd5, 0xc4, 0x1f, 0xe0, 0x5c, 0x1b, 760 | 0x2d, 0x78, 0xdb, 0xf2, 0x7b, 0x22, 0x80, 0x60]), 761 | bytes([0xcc, 0x7c, 0x56, 0x16, 0xb2, 0xa8, 0xf3, 0xd8, 762 | 0xce, 0xfd, 0xce, 0x24, 0x30, 0x79, 0xd6, 0x61, 763 | 0x81, 0xd0, 0xb2, 0x75, 0x05, 0xd2, 0x20, 0x80, 764 | 0xd2, 0x04, 0x88, 0xa4, 0x1d, 0x3e, 0xb3, 0x90]), 765 | bytes([0xea, 0x6b, 0x57, 0xfc, 0x9e, 0x35, 0xdb, 0xcf, 766 | 0x5b, 0xca, 0x4c, 0xd3, 0x35, 0xd0, 0x9f, 0xe0, 767 | 0x38, 0x3c, 0xfc, 0x14, 0x50, 0x12, 0x3e, 0x14, 768 | 0xd9, 0x3f, 0x53, 0xe9, 0x05, 0x2f, 0x8d, 0x6d]), 769 | bytes([0xa4, 0x50, 0x01, 0x92, 0x49, 0x4e, 0x81, 0xcd, 770 | 0x09, 0x35, 0xc5, 0x01, 0xa4, 0x0d, 0x71, 0x9e, 771 | 0xaa, 0xcc, 0x10, 0x56, 0x67, 0x6e, 0x66, 0x60, 772 | 0xa5, 0xfb, 0x54, 0xd9, 0xc2, 0x95, 0xeb, 0x28]), 773 | bytes([0x37, 0xef, 0x19, 0x13, 0x5f, 0xe7, 0xb6, 0x05, 774 | 0x09, 0xf3, 0x8f, 0x03, 0x93, 0xc0, 0xde, 0x49, 775 | 0xed, 0xb4, 0x2f, 0x12, 0x28, 0x94, 0x51, 0x9f, 776 | 0xab, 0xa5, 0x97, 0xee, 0xda, 0x48, 0x1f, 0xf2]), 777 | bytes([0x9c, 0xf7, 0x71, 0x84, 0x61, 0x99, 0x57, 0x91, 778 | 0x69, 0xff, 0x9a, 0x65, 0x43, 0xa9, 0xe3, 0x18, 779 | 0xb9, 0xd9, 0x60, 0xf0, 0x79, 0x33, 0xa5, 0xcb, 780 | 0xf0, 0xb3, 0x1b, 0x0d, 0x7b, 0x1e, 0x10, 0x9f]), 781 | bytes([0x5e, 0x42, 0x69, 0x3a, 0x91, 0x80, 0xe5, 0x34, 782 | 0xae, 0x48, 0xa2, 0xc4, 0x0b, 0xc2, 0xc7, 0x45, 783 | 0xef, 0x7a, 0x76, 0x0a, 0x8a, 0x98, 0x60, 0xe3, 784 | 0xd7, 0x45, 0x61, 0x4d, 0x4c, 0x98, 0xff, 0xeb]), 785 | bytes([0xf0, 0x66, 0xb6, 0x18, 0x81, 0xc5, 0xf7, 0xd8, 786 | 0x9c, 0x91, 0x90, 0x6e, 0xe4, 0xc0, 0x0b, 0xfe, 787 | 0xf8, 0xbf, 0xa0, 0x4a, 0x4d, 0xe4, 0x8b, 0xf7, 788 | 0xe0, 0x47, 0x81, 0x1b, 0xfd, 0x0c, 0x4a, 0xd6])]), 789 | (bytes([0x57, 0xa7, 0xf3, 0x01, 0x8e, 0x85, 0x19, 0xd9, 790 | 0xb8, 0xf6, 0xb0, 0x52, 0xaa, 0x63, 0xb6, 0xcd, 791 | 0xde, 0xf9, 0x78, 0x4e, 0x8f, 0x4e, 0xaf, 0x21, 792 | 0x9f, 0x64, 0xe8, 0xde, 0x3f, 0x73, 0x9e, 0x94]), 793 | [bytes([0x7b, 0xe3, 0x42, 0xfe, 0x2d, 0x2b, 0x7d, 0xff, 794 | 0xa3, 0xd7, 0xa8, 0xb5, 0xca, 0x1b, 0x2c, 0x05, 795 | 0x40, 0x2b, 0x82, 0x30, 0xbc, 0x3e, 0xbf, 0xc4, 796 | 0x72, 0xbb, 0x10, 0x7c, 0x1a, 0x59, 0x05, 0x0a]), 797 | bytes([0xe2, 0xb2, 0x94, 0x2e, 0xd4, 0x57, 0x6c, 0x8e, 798 | 0x84, 0x2c, 0xfd, 0x96, 0xa8, 0xfc, 0x1a, 0xd2, 799 | 0x15, 0xa3, 0x5a, 0x90, 0xc2, 0xe6, 0xbf, 0x0a, 800 | 0x68, 0x38, 0xa4, 0x89, 0x06, 0xa4, 0x25, 0xd5]), 801 | bytes([0x1e, 0x4c, 0xac, 0x41, 0x59, 0x3a, 0x88, 0xb4, 802 | 0x8a, 0x58, 0xeb, 0x78, 0x59, 0x66, 0x43, 0xb0, 803 | 0x55, 0xfb, 0x9d, 0x0a, 0x38, 0x10, 0x36, 0x82, 804 | 0x08, 0x7c, 0xf9, 0x75, 0x60, 0xba, 0xae, 0xeb]), 805 | bytes([0xed, 0xe2, 0xdc, 0x38, 0x4c, 0xc3, 0x02, 0x79, 806 | 0x6a, 0x0a, 0x8b, 0xc7, 0xca, 0x50, 0x16, 0x64, 807 | 0x10, 0xf2, 0x87, 0x82, 0xd8, 0x65, 0xaa, 0x0a, 808 | 0x27, 0x37, 0xc4, 0x0e, 0xc1, 0xc8, 0x62, 0x74]), 809 | bytes([0xcb, 0x28, 0x6f, 0xbd, 0x87, 0x38, 0x23, 0xf0, 810 | 0x77, 0xae, 0xf8, 0x69, 0xdd, 0xd1, 0x4b, 0x0d, 811 | 0x41, 0xb9, 0x3e, 0xbf, 0x19, 0xdd, 0xae, 0x9e, 812 | 0xa6, 0xb0, 0x9a, 0x39, 0x64, 0x53, 0x74, 0x93]), 813 | bytes([0xa9, 0x4f, 0x05, 0x73, 0x97, 0x6c, 0xe8, 0xd5, 814 | 0x9b, 0xb5, 0x84, 0x4d, 0x5d, 0xfc, 0xb4, 0x26, 815 | 0x29, 0xba, 0xbd, 0x31, 0x6c, 0x9b, 0xa0, 0x42, 816 | 0x11, 0x96, 0xd0, 0x24, 0x50, 0xfc, 0x42, 0x19]), 817 | bytes([0xd3, 0xb7, 0x49, 0x3d, 0xeb, 0x4e, 0x8a, 0x86, 818 | 0xc9, 0x9c, 0x24, 0x98, 0xeb, 0x6e, 0x5d, 0x9f, 819 | 0xeb, 0x41, 0x96, 0x2c, 0x83, 0x6a, 0xed, 0xad, 820 | 0x27, 0x02, 0xd6, 0x2b, 0x43, 0x83, 0x73, 0x58]), 821 | bytes([0x85, 0x55, 0xe8, 0x20, 0xc7, 0x0a, 0xcf, 0x3b, 822 | 0xc1, 0x50, 0xb9, 0x22, 0xc2, 0x63, 0x75, 0x3c, 823 | 0xf7, 0x30, 0xcc, 0xc8, 0xa8, 0x7e, 0xf0, 0x12, 824 | 0xea, 0x5a, 0x28, 0xa5, 0x4f, 0xd1, 0x13, 0x00]), 825 | bytes([0x07, 0xb2, 0x5a, 0xbe, 0xca, 0xf1, 0xab, 0x06, 826 | 0x50, 0x84, 0xc6, 0x3c, 0x73, 0x26, 0xea, 0x14, 827 | 0xfe, 0xf3, 0x22, 0xaf, 0x17, 0xd2, 0x21, 0x84, 828 | 0x56, 0xf6, 0xda, 0x87, 0x75, 0x5c, 0x95, 0xf3]), 829 | bytes([0xc8, 0x00, 0xc8, 0x40, 0x99, 0x28, 0xd9, 0xfe, 830 | 0x7b, 0x8b, 0x8a, 0xd0, 0x35, 0x79, 0xd0, 0x21, 831 | 0xc0, 0x23, 0xf5, 0xb4, 0x31, 0x72, 0x32, 0xe0, 832 | 0x47, 0x90, 0xb1, 0x96, 0x22, 0xa6, 0xa7, 0xcc])]), 833 | (bytes([0x36, 0x37, 0xec, 0x6f, 0x7b, 0x39, 0x80, 0xe2, 834 | 0xbe, 0x39, 0xd6, 0x08, 0x1e, 0x75, 0xe8, 0x01, 835 | 0xd3, 0x99, 0xe8, 0xd5, 0x45, 0x76, 0x97, 0xd8, 836 | 0x1e, 0x9b, 0x03, 0xfd, 0xe6, 0xba, 0x07, 0x79]), 837 | [bytes([0x56, 0xcb, 0x21, 0x52, 0x26, 0x53, 0xc7, 0x28, 838 | 0x1a, 0x95, 0x60, 0x67, 0x21, 0xb6, 0xd7, 0xe0, 839 | 0xe1, 0x2b, 0xa6, 0x91, 0x5e, 0x37, 0x57, 0x4a, 840 | 0x33, 0x5c, 0xe2, 0xe6, 0x7c, 0x58, 0x33, 0xea]), 841 | bytes([0x29, 0x33, 0xef, 0xaa, 0xb0, 0x47, 0xff, 0x2d, 842 | 0xd1, 0x4b, 0xe6, 0x85, 0xd0, 0x3a, 0xf7, 0x3f, 843 | 0xb8, 0x0f, 0x12, 0x98, 0x40, 0xfc, 0x47, 0xf0, 844 | 0x0e, 0x87, 0x6b, 0xba, 0xcf, 0xaf, 0x45, 0x84]), 845 | bytes([0x55, 0xfd, 0x2c, 0x70, 0xfa, 0x4c, 0xfe, 0x0f, 846 | 0x23, 0x0d, 0xa1, 0x1c, 0x53, 0x7c, 0x81, 0x3d, 847 | 0xe9, 0x14, 0x75, 0xe2, 0x8a, 0x4b, 0x94, 0x31, 848 | 0xfd, 0xbd, 0x4e, 0xa4, 0xa8, 0x7d, 0xa4, 0x0a]), 849 | bytes([0xf0, 0x85, 0x02, 0x2f, 0x56, 0x9b, 0x81, 0xeb, 850 | 0xf6, 0xa7, 0x0f, 0x6d, 0x05, 0xfb, 0xe4, 0x67, 851 | 0x46, 0x42, 0xc4, 0x9d, 0x91, 0x10, 0x1d, 0xb8, 852 | 0x68, 0xa7, 0xc7, 0x8f, 0xd7, 0xfa, 0xc2, 0x58]), 853 | bytes([0xa8, 0x10, 0xe0, 0xf6, 0x2b, 0x1b, 0x99, 0x77, 854 | 0xa9, 0x38, 0x8e, 0x9e, 0x39, 0x8f, 0xd0, 0x48, 855 | 0x11, 0x64, 0xd4, 0xdb, 0xa9, 0xef, 0x22, 0x13, 856 | 0x84, 0xde, 0xe4, 0x26, 0x5c, 0x20, 0x06, 0x05]), 857 | bytes([0xe6, 0x95, 0x90, 0x27, 0x28, 0x0c, 0x5e, 0xb6, 858 | 0xb4, 0xe4, 0x53, 0x5b, 0x6b, 0x16, 0x23, 0x37, 859 | 0xa7, 0x10, 0xaa, 0x3b, 0x70, 0xc6, 0xa5, 0x3d, 860 | 0xba, 0xb8, 0xa6, 0xde, 0x17, 0x4e, 0x13, 0x24]), 861 | bytes([0x60, 0xc3, 0x8f, 0xe3, 0x69, 0x31, 0xc7, 0x09, 862 | 0x34, 0x38, 0x00, 0xdc, 0xba, 0x15, 0x72, 0x9d, 863 | 0x48, 0xf5, 0xf4, 0x90, 0xee, 0x9b, 0x46, 0x42, 864 | 0x7e, 0x79, 0x6b, 0xf2, 0xa7, 0x66, 0xce, 0xae]), 865 | bytes([0x56, 0xac, 0xea, 0x35, 0x42, 0x6a, 0x9a, 0x17, 866 | 0x26, 0x22, 0x17, 0x19, 0x10, 0x8c, 0xca, 0xbc, 867 | 0x03, 0xb0, 0xb3, 0x0e, 0x87, 0x57, 0x72, 0x58, 868 | 0xc6, 0x72, 0x35, 0xf1, 0xb1, 0x69, 0xa9, 0xcd]), 869 | bytes([0xe9, 0xd9, 0x53, 0x0a, 0xb8, 0xe8, 0x96, 0x9b, 870 | 0xc9, 0x62, 0x76, 0x22, 0xe5, 0x16, 0x9d, 0xaa, 871 | 0xf1, 0xb8, 0xb1, 0x0d, 0x52, 0xd2, 0xad, 0x44, 872 | 0x78, 0x3c, 0x46, 0x18, 0x8d, 0x45, 0x66, 0x78]), 873 | bytes([0x48, 0xe6, 0x1f, 0x89, 0xfb, 0x86, 0x98, 0x70, 874 | 0x78, 0x50, 0xb5, 0xd0, 0xf9, 0x07, 0x33, 0x42, 875 | 0x82, 0xde, 0xf6, 0x0a, 0xa2, 0x7f, 0xd5, 0x33, 876 | 0x66, 0x71, 0xeb, 0xec, 0x6a, 0x84, 0x3a, 0xf7])]), 877 | (bytes([0x95, 0x02, 0x97, 0xf4, 0xea, 0x67, 0xb3, 0xf0, 878 | 0x73, 0xbf, 0x37, 0x6c, 0x93, 0x84, 0xfe, 0x5b, 879 | 0x4f, 0x92, 0xd8, 0xbd, 0x0a, 0xea, 0x84, 0xfe, 880 | 0x6d, 0x0b, 0x6a, 0x8a, 0x97, 0xc9, 0x06, 0x1d]), 881 | [bytes([0x9e, 0x02, 0xcf, 0x29, 0xfa, 0xd6, 0x76, 0xd3, 882 | 0xf5, 0x23, 0x18, 0x0a, 0x1c, 0xfa, 0x09, 0x8b, 883 | 0x8e, 0xf2, 0xe7, 0x5b, 0xcd, 0xa7, 0x5c, 0x8b, 884 | 0x17, 0x39, 0x1c, 0xcc, 0x05, 0xed, 0x5a, 0xd4]), 885 | bytes([0x96, 0x2e, 0xcf, 0x70, 0xa1, 0xf2, 0xb9, 0x34, 886 | 0x26, 0x06, 0xcf, 0x4d, 0xb0, 0xcb, 0x4a, 0xda, 887 | 0x5b, 0xb1, 0xf1, 0x53, 0x7b, 0xea, 0xc6, 0x3f, 888 | 0xa2, 0xfe, 0xbc, 0xf0, 0x04, 0x57, 0x1a, 0x35]), 889 | bytes([0x32, 0xb3, 0x3f, 0x42, 0x48, 0x0d, 0x5e, 0xa9, 890 | 0xf0, 0x08, 0xf7, 0x63, 0xdc, 0xf8, 0xec, 0xcc, 891 | 0x43, 0xd8, 0xf5, 0x36, 0xd2, 0x9e, 0x15, 0x28, 892 | 0xd9, 0x26, 0xf7, 0x76, 0xf1, 0x68, 0xf5, 0xd7]), 893 | bytes([0xe0, 0x85, 0xed, 0xdd, 0xb5, 0xbb, 0xcd, 0xb3, 894 | 0xd0, 0x62, 0x19, 0x81, 0x6c, 0x6e, 0xda, 0xb6, 895 | 0xa0, 0x34, 0x6d, 0x0a, 0xe1, 0x49, 0xa8, 0x62, 896 | 0xb2, 0xc5, 0x32, 0xf1, 0x14, 0xcd, 0xc8, 0xf6]), 897 | bytes([0xf1, 0xc7, 0x67, 0xa9, 0x3a, 0x65, 0x26, 0x26, 898 | 0xd6, 0x00, 0x8f, 0x3b, 0xf2, 0x76, 0x79, 0xda, 899 | 0x8d, 0x8a, 0x4e, 0x14, 0xac, 0x1f, 0x36, 0xf4, 900 | 0xbe, 0x51, 0x70, 0xf0, 0x99, 0x99, 0xa9, 0x9c]), 901 | bytes([0x58, 0xea, 0x0f, 0x82, 0x70, 0x33, 0x7a, 0x1d, 902 | 0x4d, 0xd9, 0xa7, 0x79, 0x8e, 0xea, 0xaf, 0xce, 903 | 0x7d, 0xff, 0x1b, 0x6c, 0x1a, 0x68, 0xd9, 0x34, 904 | 0x88, 0x2e, 0x1d, 0x08, 0x8e, 0x10, 0x51, 0x88]), 905 | bytes([0x8e, 0xba, 0x07, 0x8e, 0x02, 0x26, 0xa8, 0x32, 906 | 0x37, 0x07, 0x3b, 0x0d, 0xea, 0xb3, 0xc6, 0xb3, 907 | 0xa5, 0x59, 0x47, 0x28, 0x74, 0xe5, 0x3d, 0xaf, 908 | 0x72, 0x43, 0x15, 0x12, 0x71, 0xe6, 0xbe, 0x0a]), 909 | bytes([0xb5, 0x06, 0x05, 0xea, 0xa6, 0x8a, 0x5a, 0xd1, 910 | 0x63, 0x3b, 0x1e, 0xbf, 0x1d, 0xf6, 0x84, 0x25, 911 | 0xa9, 0xcd, 0xf7, 0x49, 0xe3, 0xbf, 0x6d, 0x44, 912 | 0xe8, 0x8b, 0xb3, 0x3f, 0x03, 0xae, 0x5b, 0x6c]), 913 | bytes([0x85, 0x17, 0xee, 0xff, 0xd6, 0x39, 0x5e, 0x1a, 914 | 0x2f, 0xd8, 0x64, 0x88, 0x2f, 0x57, 0x67, 0x8c, 915 | 0xcd, 0x94, 0x56, 0x32, 0xca, 0x73, 0x12, 0x7b, 916 | 0xc0, 0x2a, 0xc7, 0x74, 0xc9, 0x1f, 0x6c, 0xa7]), 917 | bytes([0x9c, 0x64, 0x81, 0x07, 0xf1, 0xef, 0x7b, 0x21, 918 | 0xef, 0x59, 0xa7, 0x91, 0x6f, 0x0f, 0x59, 0x50, 919 | 0xf1, 0x6d, 0x86, 0x12, 0x25, 0x1f, 0x4a, 0x12, 920 | 0xe9, 0xd0, 0xdd, 0x0a, 0x09, 0x69, 0x6c, 0x99])]), 921 | (bytes([0x11, 0x18, 0xeb, 0xa6, 0xfc, 0xfd, 0x29, 0xe7, 922 | 0x1d, 0x41, 0x64, 0x6d, 0x6f, 0x6e, 0x0a, 0x4b, 923 | 0x86, 0x0a, 0x70, 0x6d, 0x89, 0x78, 0xc7, 0x47, 924 | 0x16, 0x4b, 0xde, 0xc2, 0xde, 0xf3, 0xc2, 0xec]), 925 | [bytes([0x29, 0x04, 0xfc, 0x48, 0x1a, 0xf6, 0x21, 0xf8, 926 | 0x60, 0x26, 0xea, 0x3c, 0xb7, 0x06, 0xda, 0x91, 927 | 0x8d, 0x16, 0xd1, 0xdf, 0x0c, 0x86, 0xfc, 0xb6, 928 | 0x13, 0x8a, 0xa5, 0xbb, 0x6d, 0x99, 0x8f, 0xf2]), 929 | bytes([0xa0, 0xf4, 0x5b, 0x4b, 0x85, 0xe8, 0x34, 0x89, 930 | 0x46, 0x24, 0x1d, 0x43, 0xe8, 0xc7, 0xde, 0xba, 931 | 0x9f, 0x45, 0x42, 0xde, 0xdc, 0x97, 0x44, 0xeb, 932 | 0x48, 0x9f, 0x6d, 0xe0, 0x3a, 0x06, 0xeb, 0xf9]), 933 | bytes([0x21, 0x8f, 0x30, 0xc1, 0x4d, 0x02, 0xe6, 0x8c, 934 | 0x66, 0xe7, 0xc8, 0xa8, 0xfc, 0x90, 0x78, 0x65, 935 | 0x14, 0x07, 0x67, 0x1f, 0x87, 0x67, 0xb3, 0x3a, 936 | 0xd3, 0xb8, 0xd1, 0xa4, 0x0e, 0xaa, 0xf0, 0xb6]), 937 | bytes([0xaa, 0x06, 0x4f, 0xf1, 0xb8, 0xb4, 0x1a, 0xa8, 938 | 0x6b, 0x7f, 0x78, 0x9f, 0x7d, 0xf2, 0x20, 0x68, 939 | 0x7c, 0x7d, 0x4f, 0x4a, 0xb0, 0xef, 0xf7, 0x4b, 940 | 0xf8, 0x37, 0x09, 0xa3, 0x46, 0x30, 0xfd, 0x2a]), 941 | bytes([0xb4, 0x90, 0x34, 0xdf, 0x48, 0xce, 0x4a, 0xf3, 942 | 0x8a, 0xb0, 0xb0, 0x02, 0x42, 0x4e, 0x1a, 0xcf, 943 | 0x76, 0x0f, 0x32, 0x44, 0x71, 0x17, 0x50, 0xd4, 944 | 0xd6, 0xa4, 0xda, 0x72, 0xd6, 0xa6, 0xeb, 0x4f]), 945 | bytes([0x42, 0x9e, 0x94, 0x39, 0xf0, 0x3f, 0x19, 0x84, 946 | 0x7d, 0xd0, 0x11, 0xab, 0x3f, 0x79, 0xd6, 0xce, 947 | 0xdc, 0x14, 0xbb, 0x3c, 0x55, 0x13, 0x88, 0x65, 948 | 0xa0, 0x2a, 0x28, 0x90, 0x31, 0x16, 0x83, 0x2b]), 949 | bytes([0xda, 0x59, 0x4b, 0xe4, 0xfd, 0x3a, 0xf1, 0x9d, 950 | 0xd0, 0xca, 0xb2, 0xac, 0x15, 0x16, 0xd8, 0xba, 951 | 0xb1, 0xb9, 0xe6, 0xc3, 0xfc, 0xa5, 0xdd, 0xc2, 952 | 0x39, 0x62, 0x5c, 0x9f, 0x81, 0xe1, 0xb3, 0xce]), 953 | bytes([0xc0, 0xa6, 0x68, 0xf5, 0x48, 0x3b, 0xe6, 0x38, 954 | 0x4d, 0x00, 0x8d, 0xda, 0x77, 0x43, 0x7c, 0x6a, 955 | 0x9e, 0xdb, 0xb6, 0xde, 0xc0, 0x73, 0xdf, 0x78, 956 | 0xc3, 0xd8, 0xbc, 0xad, 0xf2, 0x09, 0x43, 0x61]), 957 | bytes([0x3d, 0x94, 0x38, 0x45, 0x88, 0xe3, 0x82, 0xed, 958 | 0x6f, 0x1b, 0x0e, 0x11, 0x6c, 0x05, 0x2b, 0x97, 959 | 0xed, 0x9f, 0xa3, 0x6b, 0xbd, 0xbf, 0xdc, 0xcb, 960 | 0xa9, 0xd9, 0x42, 0x5b, 0x5e, 0x7b, 0x28, 0x8b]), 961 | bytes([0x57, 0x9c, 0xc9, 0x2e, 0x62, 0xe0, 0x2e, 0x26, 962 | 0x3d, 0x01, 0x29, 0x13, 0x59, 0xc1, 0x6f, 0xed, 963 | 0x22, 0xbb, 0xf0, 0x86, 0x09, 0xe1, 0x8c, 0x3d, 964 | 0x6c, 0x62, 0xb5, 0xa3, 0xad, 0x67, 0xa3, 0x32])]), 965 | (bytes([0x61, 0x7e, 0xde, 0xee, 0x0f, 0x88, 0xd3, 0x96, 966 | 0x9e, 0x8d, 0xd3, 0x97, 0xc0, 0xde, 0x0f, 0x25, 967 | 0x7a, 0xa5, 0x5b, 0x12, 0x6d, 0x0b, 0xa3, 0x1d, 968 | 0xe7, 0xa2, 0x4d, 0xb7, 0x84, 0x96, 0x89, 0x62]), 969 | [bytes([0xdc, 0xf0, 0x5f, 0xea, 0xb7, 0xd4, 0xb0, 0x49, 970 | 0x8c, 0xac, 0x71, 0x95, 0x37, 0x16, 0x67, 0xe7, 971 | 0xc1, 0x7b, 0xb4, 0xf2, 0x2c, 0x7d, 0x6f, 0xf6, 972 | 0x0a, 0x3d, 0xda, 0x03, 0xb8, 0x7c, 0x53, 0xd2]), 973 | bytes([0xb3, 0x43, 0x49, 0x70, 0x59, 0xc2, 0xe1, 0x8f, 974 | 0xb3, 0x0d, 0x2b, 0xcb, 0x64, 0x2a, 0x22, 0xda, 975 | 0x49, 0xd9, 0x5c, 0x4d, 0xbb, 0xd4, 0xe7, 0xff, 976 | 0x16, 0x10, 0xd4, 0x8f, 0x06, 0x4d, 0x12, 0xe0]), 977 | bytes([0xd0, 0x43, 0x30, 0x15, 0xf7, 0x06, 0xfa, 0x2a, 978 | 0x50, 0x0b, 0x10, 0x0d, 0xe2, 0xe2, 0x87, 0x9f, 979 | 0xfd, 0x04, 0x3d, 0x1b, 0x82, 0x1a, 0xef, 0x2c, 980 | 0xfc, 0xd8, 0xb4, 0x26, 0x86, 0x90, 0xf6, 0xd8]), 981 | bytes([0x99, 0x69, 0x6d, 0x5e, 0x85, 0x91, 0x33, 0xc6, 982 | 0x6f, 0xad, 0xed, 0x9f, 0x1a, 0x65, 0x5f, 0x48, 983 | 0xab, 0x50, 0x0e, 0x4b, 0x99, 0x84, 0x47, 0xbf, 984 | 0x50, 0xf9, 0x07, 0x4c, 0x1a, 0x1c, 0x79, 0x3f]), 985 | bytes([0x59, 0x47, 0x75, 0xa1, 0x6b, 0x1b, 0xde, 0xdd, 986 | 0x8d, 0x7d, 0xfb, 0x0e, 0x75, 0x15, 0xb0, 0xa9, 987 | 0x49, 0xf7, 0xc3, 0x7e, 0x5d, 0x8c, 0x3c, 0x8c, 988 | 0x11, 0xb9, 0x18, 0x91, 0x2c, 0x95, 0xf9, 0x53]), 989 | bytes([0x0d, 0xe1, 0xfc, 0xa7, 0x46, 0xda, 0x1d, 0x9f, 990 | 0xe8, 0x37, 0x5c, 0x40, 0x72, 0x0e, 0x73, 0x2c, 991 | 0xf7, 0x50, 0xcf, 0xf5, 0xf8, 0x3e, 0x2f, 0xeb, 992 | 0x62, 0xbb, 0x44, 0x10, 0xb1, 0x76, 0xa0, 0x70]), 993 | bytes([0x88, 0xc4, 0x0c, 0x4f, 0xcd, 0x54, 0xb9, 0x8d, 994 | 0xe0, 0x58, 0x77, 0x4a, 0x70, 0x91, 0xce, 0x26, 995 | 0x47, 0xe5, 0xf8, 0x6f, 0x4b, 0xdf, 0xe9, 0xed, 996 | 0xff, 0xc2, 0x68, 0xb4, 0x03, 0xde, 0xe5, 0xc1]), 997 | bytes([0xfa, 0x87, 0x60, 0x58, 0xf8, 0xec, 0x75, 0x99, 998 | 0xe7, 0xfe, 0x6d, 0xb0, 0xc0, 0xb1, 0x35, 0x01, 999 | 0x88, 0xb4, 0xe9, 0xd0, 0x68, 0xf9, 0x2e, 0x1a, 1000 | 0x30, 0xeb, 0xf2, 0x4f, 0x28, 0x58, 0x00, 0xd8]), 1001 | bytes([0x78, 0x1b, 0x78, 0x78, 0x11, 0xc9, 0x68, 0xd9, 1002 | 0x24, 0xca, 0x56, 0xed, 0xf4, 0x05, 0x06, 0xc3, 1003 | 0x9b, 0xbc, 0xe7, 0x86, 0x02, 0xf8, 0x7e, 0x89, 1004 | 0x94, 0xa1, 0xcd, 0xba, 0x0a, 0x26, 0x6d, 0x19]), 1005 | bytes([0xa0, 0xdb, 0x21, 0x0b, 0xd2, 0xc4, 0xb0, 0x75, 1006 | 0x1c, 0x4b, 0x9c, 0x61, 0x6d, 0x76, 0xb9, 0x1e, 1007 | 0x27, 0x6c, 0xc2, 0xd8, 0xe4, 0x64, 0xb8, 0x16, 1008 | 0x79, 0xdb, 0x63, 0x78, 0xfb, 0x1d, 0xcb, 0xb7])]), 1009 | (bytes([0x2d, 0xcb, 0xb2, 0xdd, 0x59, 0xdd, 0x34, 0x17, 1010 | 0x98, 0x4f, 0xa5, 0xac, 0x87, 0x63, 0x0b, 0x6f, 1011 | 0x15, 0x41, 0x45, 0xb4, 0x7b, 0x8f, 0x78, 0xb1, 1012 | 0x45, 0xa1, 0xb3, 0x6b, 0x14, 0x75, 0xd3, 0x81]), 1013 | [bytes([0xdf, 0x00, 0xef, 0xf4, 0x81, 0x86, 0xdd, 0xb1, 1014 | 0x78, 0x8d, 0x2e, 0x44, 0x5b, 0x30, 0xd3, 0x09, 1015 | 0x3d, 0xd0, 0x98, 0x93, 0x08, 0xef, 0x73, 0x45, 1016 | 0x98, 0xb1, 0xfc, 0xea, 0x7e, 0x19, 0x47, 0x58]), 1017 | bytes([0x65, 0x82, 0xcb, 0xcc, 0xed, 0xa3, 0x3d, 0x40, 1018 | 0x8a, 0x5b, 0xcc, 0x6e, 0x8c, 0x03, 0x1d, 0x2f, 1019 | 0x99, 0x07, 0x15, 0x84, 0x5b, 0xb9, 0xd8, 0xb9, 1020 | 0x0b, 0x31, 0x0f, 0x51, 0x31, 0xc1, 0x25, 0x96]), 1021 | bytes([0x93, 0xc6, 0x8f, 0xb4, 0xec, 0x3a, 0x0f, 0xe1, 1022 | 0x50, 0x06, 0x26, 0xaa, 0xbb, 0x7f, 0x90, 0xea, 1023 | 0x53, 0x78, 0xa8, 0xb2, 0xf6, 0xaf, 0xe9, 0xc8, 1024 | 0x3e, 0x70, 0xce, 0xf0, 0xc8, 0xa6, 0xa1, 0x26]), 1025 | bytes([0x3d, 0x9a, 0xcb, 0x69, 0xdb, 0xdd, 0x95, 0x33, 1026 | 0xd9, 0xd2, 0xc4, 0xf0, 0x8b, 0x04, 0x58, 0xaa, 1027 | 0x21, 0xc8, 0xb1, 0xfd, 0x6d, 0x35, 0x9d, 0x8d, 1028 | 0xb6, 0xdb, 0x4a, 0x6b, 0x55, 0xc0, 0xb6, 0xc5]), 1029 | bytes([0xa7, 0xdd, 0x2c, 0xd7, 0x39, 0x0d, 0xfe, 0x35, 1030 | 0xb0, 0xbc, 0x2d, 0x0f, 0x9f, 0x6a, 0x7a, 0x61, 1031 | 0xc1, 0x41, 0xd9, 0xed, 0x91, 0x6f, 0x2b, 0x0f, 1032 | 0x2c, 0x72, 0x2a, 0xe1, 0xa5, 0x8d, 0x15, 0xdb]), 1033 | bytes([0x88, 0x84, 0x25, 0x5e, 0x3a, 0x7b, 0x66, 0xc1, 1034 | 0x74, 0xdb, 0xf4, 0x08, 0x3c, 0x59, 0xf7, 0x0e, 1035 | 0x88, 0xff, 0x2f, 0x20, 0x3c, 0x58, 0xd5, 0xa3, 1036 | 0x4f, 0xfd, 0x44, 0x86, 0x79, 0x02, 0x08, 0x9f]), 1037 | bytes([0x88, 0xcb, 0xa3, 0xc6, 0x86, 0xa4, 0xe3, 0x4a, 1038 | 0xcb, 0xb4, 0xec, 0x57, 0x41, 0xbe, 0x79, 0x83, 1039 | 0xc2, 0x91, 0xce, 0x35, 0xdf, 0x04, 0x09, 0xbc, 1040 | 0x58, 0x1a, 0xc7, 0xbb, 0x51, 0xcb, 0x3d, 0x7d]), 1041 | bytes([0xa9, 0xd3, 0xee, 0x22, 0x59, 0xd3, 0x6f, 0xc0, 1042 | 0xea, 0xce, 0xf8, 0x77, 0xc5, 0x37, 0x5c, 0xe7, 1043 | 0x59, 0x4a, 0x94, 0x07, 0x57, 0xad, 0x21, 0xcc, 1044 | 0xc3, 0x5b, 0xe9, 0xd4, 0xa9, 0x9f, 0xe4, 0x37]), 1045 | bytes([0x7d, 0x07, 0x77, 0xb9, 0x55, 0xe4, 0xec, 0x3e, 1046 | 0x27, 0xf3, 0xd5, 0x3e, 0xc0, 0x8f, 0xd9, 0x67, 1047 | 0xdc, 0x7f, 0x29, 0x84, 0x33, 0x79, 0x4a, 0x5a, 1048 | 0x2a, 0x56, 0xc8, 0x65, 0xf6, 0xe3, 0x93, 0x4b]), 1049 | bytes([0x3a, 0x42, 0xf2, 0x74, 0xee, 0x54, 0x6f, 0xf2, 1050 | 0x97, 0x1c, 0xb7, 0xb2, 0xa3, 0x91, 0xf2, 0x35, 1051 | 0xdc, 0x82, 0xdd, 0xee, 0x39, 0xaf, 0xab, 0xe4, 1052 | 0x2e, 0x61, 0xb1, 0xef, 0xdb, 0x8f, 0xc8, 0x86])]), 1053 | (bytes([0x81, 0xa0, 0xe9, 0x76, 0xfb, 0x1a, 0x5d, 0x4e, 1054 | 0xe1, 0xca, 0x52, 0x7f, 0x1f, 0x36, 0x54, 0xc9, 1055 | 0x2b, 0x1f, 0xa3, 0x2e, 0x7a, 0x9e, 0x69, 0x9d, 1056 | 0xd4, 0x97, 0xae, 0x84, 0x5d, 0x69, 0xfb, 0xf9]), 1057 | [bytes([0x6c, 0x24, 0x4e, 0x22, 0x8c, 0x43, 0xb1, 0x02, 1058 | 0xa4, 0x97, 0x98, 0x30, 0xb6, 0x04, 0x1e, 0x84, 1059 | 0x7c, 0x6f, 0xff, 0x8c, 0x5b, 0xdb, 0xa1, 0x1e, 1060 | 0x73, 0xbe, 0x4d, 0x5f, 0xe9, 0x2e, 0x4e, 0xf8]), 1061 | bytes([0x23, 0x2c, 0x8c, 0x69, 0xcb, 0xac, 0x71, 0xa2, 1062 | 0x48, 0x9f, 0x8c, 0xc5, 0xd6, 0x4c, 0xec, 0x54, 1063 | 0x93, 0x5f, 0xaa, 0x84, 0xef, 0x2e, 0xa6, 0x7b, 1064 | 0x34, 0x2f, 0x74, 0xe7, 0x5e, 0x1b, 0x25, 0xa2]), 1065 | bytes([0x5d, 0xe9, 0x96, 0x81, 0x9d, 0xb8, 0x82, 0x14, 1066 | 0xe8, 0x23, 0x16, 0x20, 0xc3, 0x14, 0x0b, 0xd4, 1067 | 0x8b, 0xc7, 0xc9, 0xe9, 0x70, 0x8d, 0x27, 0x45, 1068 | 0x48, 0xcc, 0x2b, 0x0a, 0x39, 0x26, 0xda, 0x67]), 1069 | bytes([0x70, 0x67, 0xd7, 0xc6, 0xd9, 0xe1, 0xdd, 0x07, 1070 | 0xd3, 0x02, 0x31, 0x7e, 0x85, 0x94, 0xf6, 0xbf, 1071 | 0xc4, 0xd7, 0xb5, 0x37, 0x10, 0x0d, 0xe9, 0x23, 1072 | 0x75, 0x72, 0x61, 0x98, 0x97, 0x70, 0x32, 0x8b]), 1073 | bytes([0xcb, 0x9f, 0xeb, 0xd3, 0xbc, 0xc0, 0x42, 0xe6, 1074 | 0x15, 0x64, 0xf1, 0x7a, 0x67, 0xe3, 0x8f, 0x99, 1075 | 0xfa, 0x95, 0x51, 0x3b, 0xef, 0x6c, 0x2e, 0x77, 1076 | 0x17, 0x6a, 0x8d, 0x2b, 0xfc, 0x16, 0x13, 0x5a]), 1077 | bytes([0xe0, 0xcd, 0x07, 0xad, 0x64, 0x56, 0x0c, 0xd7, 1078 | 0x54, 0xb3, 0x08, 0xe5, 0x1a, 0xd2, 0x6c, 0xed, 1079 | 0x3d, 0x19, 0x71, 0xee, 0x7d, 0xba, 0xff, 0xeb, 1080 | 0x75, 0x49, 0xc9, 0xd2, 0x13, 0x69, 0x72, 0xd6]), 1081 | bytes([0xb6, 0x1c, 0x13, 0xa5, 0x22, 0x33, 0xdc, 0x98, 1082 | 0x25, 0x60, 0xd4, 0xee, 0x98, 0xe3, 0x1b, 0x61, 1083 | 0xb3, 0xa0, 0x3a, 0x67, 0xe3, 0xe0, 0xcd, 0xd1, 1084 | 0x5d, 0xd3, 0x4e, 0x8f, 0x03, 0xb1, 0x46, 0x13]), 1085 | bytes([0xaf, 0x74, 0x88, 0x8a, 0x09, 0x95, 0x6a, 0xd2, 1086 | 0xa6, 0x1b, 0x8e, 0xdb, 0x57, 0x86, 0x9d, 0x01, 1087 | 0xb8, 0xc2, 0xb0, 0xb5, 0x02, 0xab, 0x17, 0xc0, 1088 | 0x5d, 0x20, 0x56, 0x6e, 0xd2, 0x4c, 0x1a, 0xfc]), 1089 | bytes([0xa6, 0x65, 0x33, 0x09, 0x28, 0xf8, 0xfd, 0xf8, 1090 | 0x99, 0x21, 0x9e, 0xf8, 0x24, 0xc6, 0x35, 0x8f, 1091 | 0x02, 0x5b, 0x5d, 0xac, 0x5b, 0xc5, 0xe5, 0xe0, 1092 | 0xc0, 0x09, 0x6a, 0x03, 0xb1, 0x3c, 0xb0, 0x66]), 1093 | bytes([0x08, 0xb1, 0x4f, 0xba, 0xbe, 0x6e, 0xbf, 0xbe, 1094 | 0x1e, 0x27, 0xd1, 0x25, 0xd8, 0xb2, 0xb0, 0x45, 1095 | 0x17, 0xac, 0xec, 0x6c, 0xf6, 0x40, 0x5f, 0x1c, 1096 | 0xd6, 0x64, 0xb0, 0xdf, 0x57, 0x56, 0xd0, 0x17])]), 1097 | (bytes([0x58, 0x0c, 0x51, 0x93, 0x0f, 0xc4, 0x1c, 0x95, 1098 | 0xa6, 0x97, 0x95, 0x1c, 0x7e, 0x33, 0x43, 0x40, 1099 | 0x98, 0x2d, 0x88, 0xd3, 0x92, 0x9b, 0xdc, 0x15, 1100 | 0x46, 0x2e, 0xa9, 0x8c, 0xe5, 0x36, 0x31, 0x1c]), 1101 | [bytes([0x7d, 0x69, 0x68, 0x92, 0x4a, 0x63, 0x96, 0x1f, 1102 | 0xf4, 0x3f, 0x5b, 0x61, 0x9d, 0x74, 0xd8, 0xc4, 1103 | 0x4a, 0xa8, 0x43, 0xa5, 0xb6, 0x3b, 0xf0, 0x91, 1104 | 0x53, 0x1f, 0x39, 0x4a, 0xe0, 0x22, 0xa1, 0x82]), 1105 | bytes([0x63, 0x50, 0x13, 0x62, 0x35, 0x8c, 0x24, 0x7f, 1106 | 0x16, 0x3a, 0xf1, 0xde, 0xd3, 0x1a, 0xc1, 0x54, 1107 | 0x4c, 0xb4, 0x58, 0xbc, 0x53, 0xc1, 0x41, 0x36, 1108 | 0xaa, 0xf4, 0x33, 0xff, 0x6b, 0x9c, 0x76, 0x94]), 1109 | bytes([0xb5, 0xed, 0xc5, 0x25, 0xa5, 0x17, 0x98, 0x4e, 1110 | 0xc8, 0x94, 0x5d, 0xb4, 0x4e, 0x5b, 0x17, 0xd4, 1111 | 0x32, 0x0a, 0xdd, 0xd2, 0x4c, 0x0a, 0xb4, 0x29, 1112 | 0x0a, 0x69, 0x51, 0x4c, 0x27, 0x9a, 0x84, 0x13]), 1113 | bytes([0xa7, 0x3c, 0x7b, 0x0d, 0x74, 0xa4, 0x86, 0x78, 1114 | 0x17, 0x33, 0xd4, 0xfa, 0x31, 0xc1, 0xdb, 0x70, 1115 | 0x72, 0x5d, 0x2a, 0xab, 0x48, 0xaa, 0xc7, 0xa7, 1116 | 0x26, 0x0d, 0x19, 0x31, 0x63, 0x57, 0x68, 0x08]), 1117 | bytes([0x10, 0x6c, 0xfd, 0x69, 0xa7, 0x38, 0xc6, 0x60, 1118 | 0x47, 0xfc, 0x1f, 0x35, 0x1c, 0x2c, 0x86, 0x74, 1119 | 0xce, 0xf5, 0x19, 0x25, 0xbe, 0x6d, 0x73, 0x14, 1120 | 0x81, 0x4e, 0x7c, 0xb7, 0x8c, 0x43, 0x61, 0xf1]), 1121 | bytes([0x21, 0x8f, 0xe6, 0x23, 0x3d, 0x58, 0xfd, 0x33, 1122 | 0xf4, 0x5e, 0x3a, 0x78, 0x33, 0xe1, 0x04, 0x5f, 1123 | 0x61, 0xc4, 0xf8, 0x59, 0xdf, 0x35, 0x0e, 0x83, 1124 | 0x52, 0x40, 0xd9, 0x0a, 0xd0, 0x42, 0xef, 0x55]), 1125 | bytes([0x7e, 0x3a, 0x1d, 0xc0, 0xbe, 0xb2, 0xb2, 0xce, 1126 | 0x6e, 0xc7, 0x4f, 0xdd, 0x72, 0x28, 0x29, 0xb2, 1127 | 0x55, 0x14, 0x3a, 0x57, 0x2a, 0xff, 0x8c, 0x5e, 1128 | 0xc3, 0xf0, 0x61, 0x1a, 0xb9, 0xb4, 0x2e, 0x0c]), 1129 | bytes([0xf4, 0x84, 0x91, 0x25, 0xb3, 0x78, 0x7f, 0x20, 1130 | 0x03, 0xe2, 0xe0, 0x4a, 0x06, 0x7d, 0x48, 0xe8, 1131 | 0x9c, 0xeb, 0x5b, 0x7e, 0x57, 0x79, 0x71, 0x6c, 1132 | 0x12, 0x62, 0xe4, 0x61, 0x02, 0x56, 0xf2, 0xce]), 1133 | bytes([0xc6, 0xda, 0x97, 0x80, 0x2d, 0xd2, 0xb9, 0x55, 1134 | 0x3f, 0x0b, 0x70, 0xd7, 0x9b, 0x24, 0xc0, 0xa6, 1135 | 0xce, 0xd7, 0xcd, 0xbf, 0x56, 0xb2, 0x10, 0x3b, 1136 | 0xc6, 0xa5, 0x67, 0x5f, 0x52, 0x42, 0xc9, 0x57]), 1137 | bytes([0xf0, 0xd3, 0x6d, 0x34, 0xbc, 0x65, 0xa0, 0x4f, 1138 | 0x28, 0x34, 0x5a, 0x53, 0xe5, 0xd0, 0x1c, 0x0a, 1139 | 0x21, 0xd1, 0x1c, 0xbe, 0x28, 0x92, 0x89, 0x73, 1140 | 0xa3, 0xc4, 0xf2, 0xae, 0x79, 0x29, 0x3d, 0xc9])]), 1141 | (bytes([0x07, 0xa0, 0x93, 0x8c, 0xe4, 0x1a, 0xe4, 0xb7, 1142 | 0x53, 0x51, 0xcc, 0x27, 0xb7, 0x09, 0x3f, 0xe9, 1143 | 0xea, 0xe9, 0xc2, 0xac, 0xe6, 0x67, 0x62, 0xfb, 1144 | 0x31, 0xfc, 0xf8, 0x4f, 0x65, 0x49, 0x31, 0xa4]), 1145 | [bytes([0x34, 0x6c, 0xbf, 0xb8, 0x6b, 0xc4, 0x28, 0x1f, 1146 | 0x04, 0xfa, 0x19, 0x68, 0xcf, 0x5b, 0x03, 0x95, 1147 | 0x27, 0x08, 0xb4, 0xe3, 0xa7, 0x91, 0x9b, 0xee, 1148 | 0x9a, 0x68, 0xca, 0xe1, 0x0e, 0x4a, 0xf0, 0xdc]), 1149 | bytes([0x13, 0x75, 0x6e, 0xd1, 0x2d, 0xf2, 0xc8, 0xb0, 1150 | 0x8d, 0x5a, 0xf4, 0xa7, 0x2b, 0x33, 0x97, 0x09, 1151 | 0xd6, 0x77, 0xb1, 0x05, 0xe8, 0x66, 0xe6, 0x3d, 1152 | 0xdf, 0x0c, 0xda, 0x47, 0x7f, 0x87, 0x05, 0xc2]), 1153 | bytes([0x47, 0x39, 0x77, 0x74, 0x46, 0xac, 0xd8, 0x8d, 1154 | 0xdc, 0x7f, 0xd5, 0xe2, 0x2c, 0xb0, 0x26, 0x0f, 1155 | 0x7f, 0x57, 0x62, 0xe1, 0x28, 0xab, 0x05, 0xc5, 1156 | 0x2c, 0x47, 0xfa, 0x72, 0xe0, 0xe7, 0x0b, 0x56]), 1157 | bytes([0xe1, 0x3f, 0xaa, 0xa0, 0x3b, 0xb4, 0xe2, 0x7b, 1158 | 0xe0, 0xa3, 0xc3, 0xe7, 0xcf, 0x02, 0x53, 0xe4, 1159 | 0x05, 0x8c, 0x96, 0xd0, 0xdd, 0x57, 0x2a, 0xe6, 1160 | 0x39, 0x78, 0xe5, 0xa5, 0x5d, 0xea, 0x49, 0xee]), 1161 | bytes([0x76, 0x58, 0x41, 0xcc, 0x2e, 0x4f, 0x52, 0x56, 1162 | 0xec, 0xe8, 0x43, 0xe1, 0x1e, 0x54, 0x53, 0x68, 1163 | 0x9f, 0x45, 0x3b, 0x48, 0x87, 0xe5, 0xc3, 0x82, 1164 | 0x83, 0xd0, 0xe5, 0xc7, 0x14, 0xd9, 0x62, 0x07]), 1165 | bytes([0x83, 0xbc, 0xd4, 0xc9, 0x9e, 0x53, 0xa7, 0x3c, 1166 | 0xa5, 0xaa, 0xf6, 0x80, 0x3e, 0x4b, 0xb5, 0xf4, 1167 | 0xe3, 0x78, 0xb7, 0xd0, 0x32, 0x5b, 0x26, 0xca, 1168 | 0x62, 0xfc, 0x6e, 0x59, 0x62, 0xe4, 0x74, 0x05]), 1169 | bytes([0x9a, 0xb6, 0x5e, 0x5d, 0xfe, 0x46, 0x4c, 0xee, 1170 | 0x37, 0xc9, 0x4c, 0xf2, 0xea, 0xf4, 0x75, 0xcb, 1171 | 0x66, 0x7d, 0x0f, 0x5c, 0x44, 0x1b, 0xa4, 0x1a, 1172 | 0xd5, 0x91, 0x03, 0xab, 0xfd, 0xc7, 0x9a, 0x6c]), 1173 | bytes([0xc5, 0x4b, 0xfd, 0x03, 0x20, 0xa6, 0x71, 0x9b, 1174 | 0x1a, 0x6b, 0x40, 0x02, 0x2b, 0xf4, 0x61, 0x7a, 1175 | 0x2d, 0x70, 0xa9, 0xb0, 0xe1, 0x79, 0x70, 0x17, 1176 | 0x6a, 0x12, 0xd6, 0x2d, 0xeb, 0xc3, 0x72, 0x60]), 1177 | bytes([0x97, 0xad, 0x0e, 0xe1, 0x25, 0x14, 0x08, 0x17, 1178 | 0x20, 0x3b, 0x10, 0x9c, 0x4f, 0x2a, 0x61, 0x69, 1179 | 0x86, 0xfb, 0x68, 0x08, 0x8c, 0x40, 0x79, 0xd4, 1180 | 0xd0, 0x58, 0xd0, 0xcb, 0x19, 0xae, 0x1a, 0xed]), 1181 | bytes([0xb9, 0x39, 0x96, 0xc1, 0x34, 0x69, 0x1d, 0x2f, 1182 | 0xa5, 0xfd, 0xb6, 0x2c, 0x5d, 0xbe, 0xb2, 0x11, 1183 | 0x89, 0x11, 0x9b, 0xde, 0x65, 0x96, 0x58, 0x83, 1184 | 0xfe, 0xcd, 0x43, 0xe3, 0xa2, 0xa7, 0xa8, 0x80])]), 1185 | (bytes([0x15, 0xc9, 0x65, 0xd5, 0x11, 0xe5, 0x60, 0x82, 1186 | 0x97, 0x15, 0x42, 0xc1, 0x2f, 0xf4, 0xa5, 0x2e, 1187 | 0x13, 0x98, 0xf5, 0x9a, 0xf0, 0x7a, 0xd7, 0x95, 1188 | 0x8f, 0xae, 0xf1, 0x2d, 0xeb, 0x99, 0xd1, 0xc4]), 1189 | [bytes([0xf4, 0xc4, 0xd7, 0xe7, 0x68, 0x6c, 0x24, 0xa0, 1190 | 0xcf, 0x58, 0xef, 0xc2, 0x4b, 0x3f, 0x25, 0x4e, 1191 | 0x46, 0xc2, 0x36, 0x90, 0x37, 0x0b, 0xbd, 0x45, 1192 | 0xb7, 0x45, 0xa7, 0xaf, 0x7e, 0x1e, 0x7a, 0xc7]), 1193 | bytes([0x0e, 0x68, 0x87, 0xb2, 0x0b, 0xb9, 0xf8, 0x98, 1194 | 0xa8, 0xaf, 0xf5, 0x04, 0x30, 0x69, 0x45, 0xc3, 1195 | 0x90, 0xba, 0x74, 0x9b, 0x6d, 0x43, 0x10, 0xe2, 1196 | 0xcb, 0x25, 0x90, 0x21, 0x54, 0xcd, 0x0f, 0xe2]), 1197 | bytes([0xd5, 0xb7, 0x11, 0x58, 0x4f, 0x8e, 0x95, 0xcf, 1198 | 0x2c, 0x68, 0x4d, 0x97, 0x31, 0x78, 0x9c, 0x47, 1199 | 0xec, 0x14, 0x35, 0xb5, 0x5b, 0xee, 0xa5, 0xe4, 1200 | 0x57, 0x17, 0x09, 0xb1, 0xe3, 0x96, 0xec, 0x66]), 1201 | bytes([0xc5, 0x4a, 0xf3, 0x25, 0x78, 0x67, 0xec, 0x7a, 1202 | 0x0f, 0x25, 0x66, 0xd4, 0x3c, 0xce, 0xe3, 0xcd, 1203 | 0x70, 0x8f, 0x31, 0xa2, 0xe9, 0x4e, 0x90, 0x7f, 1204 | 0x2b, 0xc1, 0x61, 0x82, 0xde, 0x64, 0x21, 0x72]), 1205 | bytes([0xdb, 0x74, 0xfa, 0x2f, 0x19, 0xdc, 0xeb, 0x04, 1206 | 0x21, 0x70, 0x60, 0x50, 0xa8, 0xab, 0x55, 0x42, 1207 | 0xe8, 0xf0, 0xa9, 0xf4, 0xfe, 0xa3, 0x1d, 0x35, 1208 | 0x13, 0x2e, 0x75, 0x61, 0x64, 0xeb, 0x06, 0x6b]), 1209 | bytes([0xec, 0xa8, 0x58, 0xce, 0x61, 0x03, 0xfe, 0x46, 1210 | 0x71, 0xfd, 0x0c, 0x89, 0x35, 0xda, 0x51, 0xc3, 1211 | 0x99, 0xed, 0x2e, 0x8b, 0x45, 0x17, 0x5e, 0xc7, 1212 | 0xda, 0xe4, 0x80, 0x76, 0x5e, 0x95, 0x19, 0x84]), 1213 | bytes([0x51, 0x96, 0x40, 0x03, 0x2c, 0x53, 0xc4, 0x65, 1214 | 0xa0, 0x66, 0x95, 0x45, 0x67, 0xa7, 0x13, 0x03, 1215 | 0x4c, 0x1f, 0xff, 0xe0, 0x47, 0x19, 0x76, 0x8e, 1216 | 0x3f, 0xfe, 0x03, 0x4f, 0x30, 0x4f, 0xef, 0xd9]), 1217 | bytes([0x0a, 0x0d, 0xeb, 0xf7, 0x85, 0xcc, 0xaa, 0x48, 1218 | 0x9f, 0xf5, 0x32, 0xf6, 0x42, 0x37, 0x97, 0x41, 1219 | 0x42, 0x7b, 0x6e, 0x3a, 0x52, 0x24, 0x4a, 0x57, 1220 | 0xb2, 0xb0, 0xfd, 0x33, 0x9e, 0x04, 0x8d, 0x53]), 1221 | bytes([0x49, 0x33, 0x18, 0x11, 0xcd, 0xc9, 0x1c, 0xbb, 1222 | 0x7f, 0xe8, 0x46, 0x8a, 0x85, 0xc4, 0xfa, 0x01, 1223 | 0x98, 0xac, 0x18, 0xee, 0x2b, 0xd7, 0xf3, 0x59, 1224 | 0x03, 0xa4, 0x04, 0x5c, 0xd7, 0xee, 0x22, 0xc5]), 1225 | bytes([0xde, 0x59, 0xfa, 0xb9, 0x66, 0x0e, 0x35, 0xb7, 1226 | 0x4d, 0xf6, 0x78, 0xa5, 0x11, 0x31, 0x49, 0xc5, 1227 | 0x2d, 0x9d, 0x33, 0xc0, 0xd5, 0x2c, 0x36, 0x98, 1228 | 0x61, 0x91, 0x22, 0xbd, 0x42, 0x3b, 0x10, 0xf5])]), 1229 | (bytes([0xb6, 0x6c, 0x0d, 0x33, 0x05, 0x0c, 0x19, 0x20, 1230 | 0x66, 0xd7, 0x23, 0x3f, 0xb4, 0xdd, 0x8f, 0x96, 1231 | 0xa0, 0xd2, 0x03, 0xfe, 0xdc, 0xe9, 0x44, 0x1a, 1232 | 0x6c, 0x64, 0x9b, 0xa5, 0x3b, 0x7c, 0xc3, 0x7f]), 1233 | [bytes([0xdd, 0x5d, 0x6a, 0x8d, 0x11, 0xfc, 0xb4, 0x33, 1234 | 0x5f, 0x61, 0x7f, 0xe4, 0x93, 0xe8, 0xd5, 0x4a, 1235 | 0xb2, 0x4b, 0xf5, 0x52, 0x75, 0x8b, 0x61, 0xeb, 1236 | 0x4f, 0x6e, 0x1a, 0x0d, 0x63, 0x95, 0xba, 0x29]), 1237 | bytes([0xf8, 0xbc, 0xa2, 0x5f, 0x5b, 0x2e, 0x13, 0x13, 1238 | 0xd2, 0x79, 0x59, 0x1a, 0x5a, 0x2b, 0x22, 0x89, 1239 | 0xa3, 0x70, 0xbf, 0x27, 0x0d, 0x5c, 0xbc, 0x78, 1240 | 0xdc, 0x2d, 0x6a, 0xef, 0x8f, 0xbc, 0x3a, 0xf6]), 1241 | bytes([0x50, 0xec, 0x19, 0xba, 0x9e, 0x1d, 0xa5, 0xe5, 1242 | 0x36, 0x77, 0x2c, 0x9c, 0x9d, 0xec, 0x8c, 0x9b, 1243 | 0x61, 0x5e, 0x8a, 0x5f, 0xa3, 0xa5, 0x68, 0x99, 1244 | 0x62, 0x53, 0xbf, 0xb3, 0x05, 0xde, 0x5d, 0xfb]), 1245 | bytes([0x78, 0x19, 0xef, 0x0a, 0xdf, 0x0f, 0x94, 0xdc, 1246 | 0xf0, 0x50, 0x1e, 0x18, 0x1f, 0x9c, 0x26, 0xde, 1247 | 0xa0, 0x09, 0x6d, 0xe0, 0x34, 0xdf, 0x66, 0x96, 1248 | 0xa5, 0x6e, 0xc4, 0xa0, 0xb7, 0x36, 0x7b, 0x0b]), 1249 | bytes([0x77, 0xde, 0x61, 0x30, 0xcc, 0x93, 0xc9, 0xba, 1250 | 0x30, 0xf4, 0x37, 0x9f, 0x3b, 0xf6, 0xff, 0x23, 1251 | 0x99, 0xd3, 0x76, 0x72, 0x66, 0x40, 0xda, 0xf7, 1252 | 0x11, 0x3c, 0x35, 0x36, 0x7b, 0xd1, 0xcd, 0x51]), 1253 | bytes([0x3f, 0x5b, 0x1e, 0x5e, 0xaf, 0x1f, 0x30, 0xc4, 1254 | 0x02, 0xe7, 0x8d, 0x5a, 0xea, 0x18, 0x9e, 0x9d, 1255 | 0xd9, 0x7c, 0x40, 0xfa, 0xa5, 0x63, 0xd7, 0x1a, 1256 | 0x7f, 0x99, 0xd0, 0x7d, 0x5f, 0x4a, 0x50, 0x5c]), 1257 | bytes([0x8e, 0x70, 0x95, 0x7a, 0xee, 0xa2, 0x40, 0x51, 1258 | 0x0f, 0x95, 0xa0, 0x87, 0xfa, 0x0a, 0xf0, 0x9a, 1259 | 0xfd, 0x43, 0x89, 0x17, 0x72, 0xf6, 0x63, 0x8b, 1260 | 0x84, 0x41, 0xda, 0x67, 0x48, 0x17, 0xa4, 0xb9]), 1261 | bytes([0x12, 0x95, 0x7b, 0x83, 0x01, 0xcb, 0x00, 0x3c, 1262 | 0xbd, 0x1b, 0xe7, 0xb3, 0x08, 0xac, 0xc8, 0x19, 1263 | 0x83, 0x65, 0x5c, 0x32, 0x7a, 0x1a, 0x00, 0x85, 1264 | 0xbb, 0xc9, 0x01, 0x9d, 0xea, 0xf3, 0xfa, 0x27]), 1265 | bytes([0xbc, 0x17, 0x0e, 0xb5, 0x7c, 0x18, 0xc7, 0x2b, 1266 | 0x75, 0x7f, 0x4c, 0xc0, 0x87, 0xc1, 0x1f, 0x19, 1267 | 0x8a, 0x27, 0xdf, 0x09, 0x75, 0x26, 0x8c, 0x8a, 1268 | 0xa9, 0xad, 0xaa, 0xaa, 0xef, 0x2f, 0xe0, 0x74]), 1269 | bytes([0x71, 0x35, 0x55, 0x3a, 0xfa, 0x1b, 0x10, 0xbc, 1270 | 0x78, 0x73, 0x65, 0xb6, 0xce, 0x38, 0x63, 0x29, 1271 | 0x86, 0x79, 0xd3, 0x56, 0xab, 0x54, 0x6f, 0x0e, 1272 | 0xfa, 0x3a, 0x0e, 0xd5, 0x4a, 0x03, 0xd6, 0x5a])]), 1273 | (bytes([0x3d, 0xa3, 0x4a, 0xb0, 0xee, 0xb8, 0xd5, 0xaa, 1274 | 0x8b, 0xa3, 0x51, 0x07, 0x62, 0x33, 0xba, 0x13, 1275 | 0x2a, 0xde, 0x41, 0x27, 0x66, 0x75, 0x44, 0xc4, 1276 | 0x51, 0x4b, 0x9c, 0xce, 0xa0, 0x17, 0x24, 0x7f]), 1277 | [bytes([0x98, 0x81, 0x15, 0x4c, 0x81, 0x27, 0x4f, 0x36, 1278 | 0x31, 0xe3, 0x2b, 0x93, 0xbd, 0x4d, 0x2b, 0xb3, 1279 | 0x5f, 0x39, 0xcb, 0x69, 0xba, 0x6c, 0x82, 0x9c, 1280 | 0xad, 0x26, 0x99, 0xe6, 0x2d, 0x50, 0xb0, 0x4b]), 1281 | bytes([0xbb, 0x28, 0xbb, 0x09, 0x78, 0xf5, 0x36, 0x88, 1282 | 0x6d, 0x8e, 0x8b, 0x61, 0xc9, 0x11, 0x03, 0xa6, 1283 | 0x85, 0x6a, 0x2b, 0x32, 0x6d, 0xec, 0xc9, 0xf7, 1284 | 0xc1, 0xac, 0x1b, 0xe2, 0x3c, 0xc0, 0xcc, 0xf2]), 1285 | bytes([0x64, 0x4b, 0x3f, 0x72, 0x1a, 0xb9, 0x9e, 0x15, 1286 | 0x40, 0xcd, 0xfe, 0x3c, 0xbb, 0xd0, 0x8d, 0x2f, 1287 | 0xac, 0x48, 0x55, 0x5f, 0x3d, 0xfb, 0x73, 0x01, 1288 | 0x61, 0x93, 0xdd, 0xec, 0x3d, 0xc4, 0x02, 0x4c]), 1289 | bytes([0xe1, 0xfb, 0x83, 0x5a, 0xf2, 0xb3, 0x47, 0x16, 1290 | 0x86, 0xe5, 0x99, 0x51, 0x3d, 0xe3, 0x8e, 0x50, 1291 | 0xcf, 0x65, 0x00, 0x08, 0x43, 0x25, 0x9e, 0x8e, 1292 | 0xca, 0x38, 0xb0, 0xee, 0x17, 0x7c, 0x9c, 0x72]), 1293 | bytes([0x8a, 0x21, 0x0e, 0xef, 0xd4, 0x90, 0xf4, 0x50, 1294 | 0xbd, 0xef, 0xef, 0x9d, 0x31, 0x83, 0x11, 0xf5, 1295 | 0x93, 0x5f, 0xbe, 0xf8, 0xc5, 0x3a, 0x4e, 0xb2, 1296 | 0x5f, 0x57, 0x34, 0x7a, 0x1c, 0x97, 0xae, 0x88]), 1297 | bytes([0x6f, 0xa6, 0x3b, 0x37, 0xf5, 0xee, 0xe2, 0xff, 1298 | 0xba, 0x2c, 0xbe, 0x3b, 0x9c, 0x9a, 0xbb, 0xbc, 1299 | 0x60, 0xd9, 0xbd, 0xd2, 0xf5, 0x1d, 0x4f, 0xde, 1300 | 0x5b, 0x11, 0xb9, 0x6b, 0x1a, 0x75, 0xcc, 0x77]), 1301 | bytes([0x12, 0xad, 0x4e, 0xd5, 0x50, 0xe4, 0xb1, 0xe4, 1302 | 0xcd, 0xac, 0xd2, 0x9c, 0x67, 0x7d, 0x49, 0xb4, 1303 | 0x36, 0x6b, 0xad, 0xf0, 0xed, 0x32, 0x2c, 0x39, 1304 | 0x2c, 0x68, 0x3d, 0x5a, 0xbd, 0x4f, 0xc3, 0x79]), 1305 | bytes([0x58, 0xff, 0x0e, 0xcb, 0xa1, 0xb0, 0xfe, 0x7d, 1306 | 0x5c, 0xc6, 0x7c, 0x61, 0x29, 0x2e, 0xe8, 0x78, 1307 | 0x43, 0xb6, 0x66, 0xfe, 0x7e, 0x14, 0xaa, 0x1a, 1308 | 0xb0, 0x7f, 0x19, 0xa3, 0x8c, 0x9f, 0xad, 0xaf]), 1309 | bytes([0x5f, 0xd6, 0x2d, 0x70, 0x4d, 0x2b, 0xfe, 0x19, 1310 | 0xab, 0x5c, 0xe9, 0x14, 0x66, 0xd9, 0xc1, 0x75, 1311 | 0x2a, 0x35, 0x81, 0x9b, 0x99, 0xd7, 0x22, 0xcc, 1312 | 0x8a, 0xa1, 0x60, 0xea, 0xde, 0x9e, 0xd9, 0x32]), 1313 | bytes([0x86, 0xf4, 0xcd, 0x18, 0x15, 0xb2, 0x7c, 0x02, 1314 | 0xb2, 0x51, 0xc3, 0xb8, 0xcf, 0x36, 0xb0, 0xa8, 1315 | 0x73, 0x38, 0x77, 0x60, 0x92, 0x4a, 0x33, 0xdb, 1316 | 0x16, 0xe7, 0x56, 0x5c, 0xb6, 0xc0, 0x7b, 0x4d])]), 1317 | (bytes([0x17, 0xb0, 0xf8, 0x22, 0xa1, 0x50, 0x88, 0x61, 1318 | 0x8a, 0x85, 0xf8, 0xfc, 0x58, 0x9c, 0x89, 0xa7, 1319 | 0x94, 0x97, 0xfd, 0x2c, 0xed, 0x0e, 0xca, 0x1d, 1320 | 0xb3, 0xc1, 0x43, 0x7d, 0x9a, 0x39, 0x7e, 0x7d]), 1321 | [bytes([0xd9, 0xb5, 0xd5, 0xec, 0x36, 0xad, 0x9e, 0xde, 1322 | 0x3c, 0xea, 0x15, 0xcd, 0x52, 0x73, 0xf0, 0x29, 1323 | 0x2d, 0xbc, 0xe2, 0xb5, 0xbc, 0xb6, 0x8b, 0xc9, 1324 | 0x87, 0x71, 0x0b, 0xca, 0x78, 0x8a, 0xd9, 0x9f]), 1325 | bytes([0x20, 0xe0, 0x60, 0x26, 0xd1, 0xcb, 0x6c, 0x18, 1326 | 0xdf, 0xbc, 0x08, 0x31, 0xcb, 0x32, 0xfb, 0xa5, 1327 | 0x83, 0x26, 0x96, 0x30, 0xe2, 0xb9, 0x2e, 0xea, 1328 | 0xc7, 0x52, 0xd3, 0x01, 0x8a, 0xfb, 0x6c, 0x58]), 1329 | bytes([0xdd, 0xc9, 0x48, 0xe1, 0x1e, 0xf2, 0x55, 0xbe, 1330 | 0x3a, 0x83, 0x4f, 0x96, 0x16, 0xf7, 0x70, 0xbd, 1331 | 0x88, 0x75, 0x65, 0x53, 0xe0, 0x67, 0x17, 0x0e, 1332 | 0x63, 0x9b, 0xdd, 0xe9, 0x86, 0x1f, 0xfd, 0xca]), 1333 | bytes([0x05, 0x31, 0x74, 0x79, 0xc3, 0xe7, 0x06, 0xa4, 1334 | 0x36, 0x2b, 0x0f, 0x74, 0x71, 0x3f, 0xa9, 0x15, 1335 | 0xb3, 0xb3, 0xc4, 0xd3, 0xf5, 0x43, 0xd5, 0x27, 1336 | 0xa6, 0xa9, 0x11, 0x84, 0x33, 0xae, 0xda, 0x46]), 1337 | bytes([0x6a, 0x00, 0xe2, 0xa8, 0xe4, 0x4e, 0xa0, 0x0b, 1338 | 0x79, 0xf5, 0xaf, 0xaa, 0x64, 0x1a, 0xaa, 0xd3, 1339 | 0xf5, 0x68, 0x71, 0xce, 0x02, 0x82, 0x00, 0x7b, 1340 | 0x0b, 0x9d, 0xab, 0x58, 0xee, 0xb4, 0x64, 0x36]), 1341 | bytes([0x38, 0xff, 0x9b, 0x06, 0x33, 0x7c, 0x13, 0xc1, 1342 | 0x3d, 0xcc, 0x4d, 0xdb, 0x00, 0x2e, 0x8f, 0x4d, 1343 | 0x15, 0x63, 0x62, 0x49, 0x14, 0x4b, 0x05, 0x7f, 1344 | 0x4f, 0x31, 0xa0, 0xba, 0x9d, 0xef, 0x2c, 0x3e]), 1345 | bytes([0x03, 0x33, 0x6f, 0x0d, 0xf1, 0x00, 0x93, 0xfe, 1346 | 0x25, 0xc1, 0xb4, 0xe7, 0xc7, 0xb0, 0x1d, 0xaa, 1347 | 0xdd, 0x2b, 0xad, 0x74, 0xa5, 0x43, 0x42, 0x2d, 1348 | 0x49, 0xad, 0xb7, 0x7a, 0x34, 0xe1, 0x5f, 0x12]), 1349 | bytes([0x89, 0x9c, 0x36, 0x70, 0x38, 0x84, 0x13, 0xfe, 1350 | 0x9e, 0x99, 0xa7, 0xdb, 0xe5, 0xd5, 0x26, 0x1e, 1351 | 0x43, 0x72, 0x2b, 0xe0, 0x77, 0xb4, 0xc1, 0x38, 1352 | 0x2d, 0xe5, 0x92, 0x45, 0x79, 0x12, 0x3b, 0x5c]), 1353 | bytes([0x1a, 0x0b, 0xd4, 0x21, 0x7a, 0x4b, 0xec, 0xc4, 1354 | 0x18, 0x50, 0xb9, 0x27, 0x46, 0x05, 0xaf, 0x10, 1355 | 0xb9, 0x27, 0x72, 0x20, 0xae, 0xc0, 0xa7, 0x9a, 1356 | 0x3a, 0xc8, 0x50, 0xf8, 0xbe, 0x0b, 0xa2, 0xce]), 1357 | bytes([0x68, 0x9d, 0x9f, 0xfb, 0x76, 0x29, 0xce, 0x62, 1358 | 0x3f, 0x0e, 0x02, 0xcf, 0x46, 0xa0, 0x4b, 0x55, 1359 | 0xf3, 0x52, 0x7f, 0x1f, 0xf3, 0x51, 0x89, 0x99, 1360 | 0x8e, 0x65, 0x90, 0x8c, 0xb5, 0x99, 0x8b, 0xd3])]), 1361 | (bytes([0xd5, 0xbc, 0x4c, 0x2a, 0xdc, 0x81, 0x8e, 0x3c, 1362 | 0x10, 0x2e, 0xa6, 0xaf, 0xd6, 0x43, 0x61, 0xc0, 1363 | 0x93, 0xd9, 0xf2, 0x7e, 0x60, 0xa2, 0xb6, 0x7f, 1364 | 0x95, 0xc3, 0xb5, 0x7c, 0x2d, 0xf1, 0xae, 0x33]), 1365 | [bytes([0x6f, 0xb3, 0x79, 0x78, 0x18, 0x5f, 0xfc, 0x5b, 1366 | 0x96, 0x19, 0x7d, 0xbe, 0x13, 0xb7, 0xaf, 0x89, 1367 | 0x2f, 0x4d, 0xcd, 0xbf, 0x8f, 0x96, 0xe1, 0xea, 1368 | 0xf5, 0xfb, 0x58, 0xc2, 0x93, 0x49, 0x9f, 0xc4]), 1369 | bytes([0x54, 0x83, 0x2a, 0x41, 0x27, 0xc2, 0xab, 0xb8, 1370 | 0x02, 0x08, 0x39, 0xce, 0xfe, 0xdc, 0x83, 0x98, 1371 | 0xff, 0xf0, 0xc9, 0x3d, 0x79, 0xa2, 0x42, 0xf3, 1372 | 0xa8, 0x97, 0xc9, 0x6f, 0xf3, 0xdb, 0xe7, 0xe6]), 1373 | bytes([0xa1, 0x5b, 0x8f, 0x44, 0x39, 0xd0, 0xf6, 0x14, 1374 | 0x20, 0x0b, 0x7b, 0xa1, 0xf2, 0x8b, 0xaa, 0xe6, 1375 | 0x1a, 0x5d, 0x23, 0xc7, 0xf0, 0x82, 0xdb, 0x1d, 1376 | 0x12, 0xd5, 0x09, 0x3e, 0x66, 0x82, 0x96, 0x00]), 1377 | bytes([0x7f, 0x15, 0xaa, 0xe3, 0xc2, 0x05, 0x9f, 0x43, 1378 | 0x0a, 0x6a, 0x53, 0xbe, 0x05, 0x9f, 0xc8, 0x22, 1379 | 0xdc, 0xda, 0xea, 0xf2, 0xaf, 0x54, 0x1a, 0x51, 1380 | 0xa9, 0xc9, 0x62, 0xa9, 0x84, 0x2c, 0xc2, 0xe9]), 1381 | bytes([0x7b, 0xe1, 0x9a, 0xac, 0x6d, 0x84, 0xbc, 0x23, 1382 | 0x79, 0xdc, 0xe3, 0x3b, 0x7a, 0x91, 0x0a, 0x97, 1383 | 0x14, 0xfb, 0x35, 0x2c, 0x36, 0xdb, 0x27, 0xe5, 1384 | 0x4c, 0x19, 0x74, 0xb9, 0xe0, 0xf5, 0x29, 0x07]), 1385 | bytes([0xac, 0xfb, 0xb5, 0xfc, 0xbc, 0xf6, 0x96, 0xb7, 1386 | 0xd3, 0xe0, 0xa0, 0xc8, 0xad, 0xe2, 0xbb, 0x38, 1387 | 0xe2, 0xe1, 0x0c, 0x45, 0xe2, 0x19, 0xd5, 0x35, 1388 | 0x03, 0xcc, 0x07, 0x5f, 0x15, 0xe9, 0xdc, 0x5b]), 1389 | bytes([0x06, 0xaf, 0x19, 0x38, 0x96, 0x7f, 0x75, 0x2f, 1390 | 0x2d, 0xfa, 0xf6, 0x89, 0xea, 0xe6, 0xe6, 0x91, 1391 | 0x94, 0xe9, 0xae, 0x12, 0xbb, 0x39, 0x29, 0x7c, 1392 | 0x05, 0x29, 0x70, 0x28, 0xcd, 0x61, 0xc6, 0x14]), 1393 | bytes([0x5a, 0x1b, 0x5e, 0x0a, 0xd6, 0x8d, 0x21, 0xab, 1394 | 0x49, 0xcf, 0x6e, 0xc1, 0x88, 0x58, 0x3c, 0xe2, 1395 | 0x48, 0xfd, 0x0f, 0x87, 0x21, 0x77, 0xd4, 0xaf, 1396 | 0x3d, 0xda, 0x19, 0x87, 0x99, 0x54, 0x56, 0xe7]), 1397 | bytes([0x56, 0xca, 0x12, 0x6d, 0xbd, 0xa5, 0xcb, 0x6a, 1398 | 0x77, 0xd9, 0x05, 0xb8, 0xd9, 0xb1, 0x0b, 0x2b, 1399 | 0xa4, 0x26, 0xfa, 0xc9, 0xc3, 0x06, 0xf5, 0xc1, 1400 | 0xc8, 0x0a, 0x1c, 0xe2, 0xa2, 0x72, 0x7f, 0x85]), 1401 | bytes([0x74, 0x16, 0xf5, 0x93, 0xd3, 0x1e, 0x95, 0x11, 1402 | 0xf5, 0x8d, 0x8e, 0x71, 0xf9, 0x33, 0x3f, 0x48, 1403 | 0xd5, 0xd5, 0x36, 0x1a, 0xbc, 0xa7, 0x01, 0x68, 1404 | 0x3e, 0x03, 0xc6, 0x08, 0x4e, 0x48, 0xde, 0xab])]), 1405 | (bytes([0x95, 0x50, 0x61, 0xe2, 0x4f, 0x4f, 0xe1, 0xb4, 1406 | 0x06, 0x3b, 0xfa, 0x53, 0x70, 0xf5, 0x5f, 0xea, 1407 | 0xbd, 0x0d, 0x9a, 0x42, 0x9d, 0x63, 0x3d, 0x59, 1408 | 0x08, 0xfc, 0x8c, 0x5a, 0x68, 0x73, 0x65, 0x6f]), 1409 | [bytes([0xc7, 0xee, 0xbf, 0x50, 0xf3, 0x90, 0x88, 0xfd, 1410 | 0xdb, 0xe7, 0x61, 0x83, 0x2a, 0x06, 0xec, 0xf0, 1411 | 0x8b, 0x3f, 0xbd, 0x81, 0x83, 0x67, 0x47, 0x7b, 1412 | 0x6e, 0x71, 0x46, 0x40, 0xf0, 0x62, 0xda, 0xdf]), 1413 | bytes([0x03, 0x47, 0xa0, 0x9d, 0x95, 0x8a, 0xcd, 0x16, 1414 | 0x8f, 0x5a, 0x2d, 0x1b, 0xba, 0x98, 0x4a, 0x49, 1415 | 0xe9, 0xff, 0xe4, 0x74, 0xc3, 0xbb, 0xa1, 0x01, 1416 | 0x6d, 0xf0, 0x3e, 0x1f, 0x19, 0x7b, 0x55, 0x29]), 1417 | bytes([0x61, 0xe2, 0xb0, 0xcf, 0x78, 0x15, 0x8a, 0x96, 1418 | 0x0a, 0x4f, 0xe3, 0xc1, 0x66, 0xb3, 0xf6, 0x12, 1419 | 0x5d, 0xc7, 0x05, 0x2f, 0x9d, 0x8c, 0x3e, 0xb9, 1420 | 0xd8, 0x7f, 0xe7, 0x51, 0x0b, 0x76, 0x93, 0x06]), 1421 | bytes([0xa7, 0x61, 0xaa, 0x65, 0x23, 0x80, 0xb6, 0xa3, 1422 | 0x1e, 0x0d, 0xa1, 0xe9, 0x90, 0x99, 0x9c, 0xde, 1423 | 0xc4, 0xa0, 0x04, 0x85, 0xa7, 0xd9, 0x5c, 0x15, 1424 | 0x07, 0x92, 0xde, 0xfe, 0x91, 0x5b, 0x3f, 0x63]), 1425 | bytes([0x34, 0x54, 0xf4, 0xe1, 0xff, 0x3d, 0xa4, 0x69, 1426 | 0xdc, 0x98, 0x91, 0xf7, 0x35, 0x26, 0x88, 0x7f, 1427 | 0xb7, 0x17, 0x84, 0x81, 0xdf, 0x00, 0xed, 0x7b, 1428 | 0x98, 0xda, 0x10, 0x3e, 0xfc, 0x94, 0x8b, 0xce]), 1429 | bytes([0xb4, 0x6e, 0x82, 0x4d, 0xf8, 0xd2, 0x79, 0x9b, 1430 | 0xe0, 0x81, 0x45, 0x1b, 0x06, 0x5f, 0x4a, 0xda, 1431 | 0xd9, 0xbf, 0x77, 0xeb, 0x8d, 0xa7, 0x29, 0xc4, 1432 | 0x89, 0xcd, 0x29, 0x3b, 0x0d, 0x2e, 0x93, 0x4a]), 1433 | bytes([0xd4, 0x9d, 0x76, 0x0a, 0xdc, 0xf6, 0xb7, 0x90, 1434 | 0x63, 0x9b, 0x00, 0xdf, 0xbb, 0xf8, 0x5a, 0xb3, 1435 | 0x19, 0x7d, 0x64, 0x6d, 0xbf, 0xea, 0x93, 0xd7, 1436 | 0xc2, 0xbc, 0x3e, 0x38, 0x7b, 0x1d, 0x0d, 0x57]), 1437 | bytes([0x81, 0x88, 0x0b, 0x37, 0x69, 0x0c, 0xd3, 0xbb, 1438 | 0x0e, 0x3d, 0xc1, 0x48, 0x25, 0xb8, 0x52, 0x41, 1439 | 0x00, 0x8b, 0xbb, 0x11, 0x32, 0xb9, 0x25, 0x16, 1440 | 0x36, 0x42, 0xf7, 0x80, 0x28, 0x97, 0x1d, 0xd7]), 1441 | bytes([0x3e, 0x0d, 0x58, 0x76, 0x5b, 0xce, 0x86, 0x79, 1442 | 0x99, 0x42, 0xa0, 0x08, 0x4a, 0xb2, 0x35, 0x02, 1443 | 0x8d, 0x53, 0xf7, 0xe6, 0x46, 0xe3, 0x23, 0xc9, 1444 | 0xce, 0x16, 0x0a, 0x81, 0x14, 0xa1, 0xa2, 0x95]), 1445 | bytes([0xa1, 0x09, 0x48, 0xbb, 0x77, 0xda, 0x21, 0xea, 1446 | 0xa1, 0x89, 0x71, 0x68, 0x59, 0xd4, 0x58, 0xbd, 1447 | 0xb6, 0x37, 0xde, 0x03, 0xc1, 0xd1, 0xf3, 0xa9, 1448 | 0x18, 0xe9, 0xaf, 0x75, 0x21, 0xcd, 0x63, 0x92])]), 1449 | (bytes([0xe3, 0x02, 0xfa, 0x96, 0x0c, 0xde, 0x20, 0x0b, 1450 | 0x54, 0x4d, 0xc8, 0x6a, 0x31, 0x4a, 0xbd, 0x4e, 1451 | 0x3d, 0x83, 0x89, 0xd9, 0xa6, 0xcc, 0x19, 0x9a, 1452 | 0x34, 0xe6, 0x89, 0x9b, 0x6e, 0xa9, 0xaa, 0xc9]), 1453 | [bytes([0x77, 0x7c, 0x05, 0x52, 0xa4, 0x42, 0x24, 0x1a, 1454 | 0x22, 0xc7, 0xcc, 0x4b, 0x9a, 0x1d, 0x0a, 0xf0, 1455 | 0x47, 0xb9, 0x80, 0x2c, 0x88, 0xe8, 0xe4, 0x2d, 1456 | 0xc2, 0x9b, 0x6e, 0xa3, 0x4c, 0xd1, 0x9f, 0x5a]), 1457 | bytes([0xc7, 0xbb, 0xe1, 0x85, 0x68, 0x31, 0xf8, 0xf8, 1458 | 0x63, 0xaa, 0x58, 0x06, 0xb6, 0x63, 0xb9, 0x44, 1459 | 0x57, 0x7d, 0x61, 0x1b, 0x73, 0x31, 0x2f, 0x97, 1460 | 0xc8, 0xf2, 0xe9, 0xd9, 0x0e, 0x57, 0x8d, 0x5b]), 1461 | bytes([0xfe, 0xd8, 0xaa, 0xa6, 0x06, 0xbf, 0xf0, 0x25, 1462 | 0x2b, 0x3b, 0xd1, 0x4f, 0xd3, 0xe0, 0x4e, 0x0c, 1463 | 0x82, 0x12, 0xdb, 0xec, 0x2b, 0xfa, 0x60, 0xc1, 1464 | 0x6a, 0xa9, 0x70, 0x7d, 0xb5, 0xc7, 0x0b, 0x45]), 1465 | bytes([0x70, 0xa2, 0xb3, 0x63, 0x35, 0x2e, 0x6e, 0x21, 1466 | 0x75, 0xaf, 0x51, 0x64, 0x6b, 0x43, 0xed, 0x6f, 1467 | 0x12, 0x2b, 0xe3, 0x35, 0xd8, 0x81, 0xd3, 0xb7, 1468 | 0x09, 0xf1, 0x6d, 0x9a, 0x9b, 0x42, 0x0a, 0xb7]), 1469 | bytes([0xc3, 0x8f, 0x13, 0xe9, 0x3a, 0x6d, 0x4b, 0x33, 1470 | 0x3a, 0x19, 0x28, 0x1b, 0x20, 0x88, 0xf3, 0x1b, 1471 | 0x69, 0xdc, 0x8b, 0xbd, 0x95, 0x25, 0xc7, 0x32, 1472 | 0xdf, 0x72, 0xc1, 0x87, 0xb0, 0x24, 0xe5, 0x82]), 1473 | bytes([0x46, 0x70, 0x84, 0xf0, 0x23, 0x32, 0x70, 0x82, 1474 | 0x5d, 0xc5, 0x75, 0xb3, 0xe1, 0x1a, 0x1b, 0xb4, 1475 | 0xff, 0x10, 0xd3, 0x0c, 0xa2, 0x90, 0x1c, 0x26, 1476 | 0x12, 0x2a, 0xd5, 0x2e, 0xe6, 0x96, 0x24, 0x3b]), 1477 | bytes([0x1b, 0x85, 0x34, 0xcf, 0x48, 0xa3, 0xbc, 0x06, 1478 | 0x2f, 0xdf, 0x77, 0xb6, 0x13, 0xad, 0x13, 0xfd, 1479 | 0x43, 0x13, 0x8d, 0xe7, 0xd3, 0xd2, 0x18, 0x71, 1480 | 0x62, 0x9c, 0x2e, 0x99, 0x5f, 0x3b, 0x10, 0x74]), 1481 | bytes([0x45, 0xe8, 0x51, 0x35, 0xd5, 0x34, 0xca, 0xb7, 1482 | 0x7d, 0x2a, 0x83, 0xd6, 0x44, 0x2b, 0xc8, 0x72, 1483 | 0x05, 0xff, 0x23, 0xb2, 0x4b, 0x1a, 0x62, 0x8a, 1484 | 0xf8, 0xe4, 0x0f, 0x7d, 0x93, 0x6b, 0xbf, 0x70]), 1485 | bytes([0xe5, 0x5d, 0x89, 0x68, 0x1a, 0xc9, 0xf3, 0x1d, 1486 | 0x4f, 0x4c, 0xfe, 0x65, 0xd0, 0x8d, 0x1e, 0xb8, 1487 | 0x8c, 0xab, 0xbf, 0x1e, 0x03, 0x6b, 0x94, 0xa5, 1488 | 0x38, 0x04, 0x56, 0xbd, 0xfc, 0x77, 0xf3, 0xa6]), 1489 | bytes([0x16, 0x73, 0x2c, 0x53, 0x77, 0x52, 0xeb, 0xe7, 1490 | 0x02, 0x1a, 0x69, 0x90, 0x2f, 0x0b, 0x36, 0x93, 1491 | 0x8e, 0x64, 0x99, 0x4a, 0xad, 0x65, 0x37, 0xef, 1492 | 0xd7, 0x95, 0x71, 0x81, 0xb2, 0xfa, 0xcb, 0x27])]), 1493 | (bytes([0x03, 0x13, 0x87, 0x7b, 0xe1, 0x10, 0x14, 0x6a, 1494 | 0x2b, 0x8c, 0xf0, 0xf6, 0xea, 0x42, 0x8f, 0xef, 1495 | 0xbf, 0x76, 0x25, 0x13, 0xcd, 0x49, 0x25, 0x3b, 1496 | 0xa9, 0x83, 0x42, 0x7d, 0xad, 0xb4, 0xdf, 0x46]), 1497 | [bytes([0xf1, 0xd8, 0x34, 0x0a, 0xe0, 0x29, 0x00, 0x2d, 1498 | 0x83, 0x97, 0x0b, 0x01, 0xcd, 0xe0, 0xc4, 0xd0, 1499 | 0x61, 0xd6, 0xfa, 0x2e, 0x06, 0x90, 0x7c, 0x8e, 1500 | 0x63, 0x2c, 0xc1, 0xc5, 0x81, 0xb3, 0xa2, 0xaa]), 1501 | bytes([0xfc, 0xa9, 0x41, 0xf3, 0x34, 0xef, 0xf0, 0x0b, 1502 | 0xcc, 0xf7, 0x2e, 0xca, 0xea, 0x39, 0xb1, 0x5f, 1503 | 0xd0, 0x26, 0x26, 0xc6, 0xad, 0x4b, 0xee, 0x62, 1504 | 0xfd, 0x30, 0x58, 0x35, 0x04, 0x2a, 0x0d, 0x85]), 1505 | bytes([0x2e, 0xf7, 0x11, 0x8d, 0xda, 0x5b, 0x08, 0x32, 1506 | 0xc6, 0x6e, 0xda, 0x89, 0xff, 0xa9, 0xf0, 0x8b, 1507 | 0x7a, 0xf6, 0xb5, 0x23, 0xde, 0x76, 0x1b, 0x9f, 1508 | 0x02, 0x23, 0xfd, 0xb5, 0x5d, 0x1d, 0xec, 0xd7]), 1509 | bytes([0x4a, 0x2e, 0x79, 0xc9, 0x74, 0x3b, 0x66, 0xe0, 1510 | 0x1e, 0xe4, 0x4a, 0x50, 0x8f, 0x9b, 0x44, 0x86, 1511 | 0x8e, 0xb5, 0x7f, 0x3a, 0x52, 0x57, 0xa1, 0xe2, 1512 | 0x09, 0xda, 0x74, 0x9c, 0x86, 0x16, 0x4e, 0x84]), 1513 | bytes([0x57, 0x7f, 0x5a, 0x69, 0x1c, 0x6d, 0xdb, 0x89, 1514 | 0x24, 0x38, 0x7d, 0xe4, 0xaf, 0x6d, 0x34, 0x05, 1515 | 0x46, 0x00, 0x15, 0x25, 0x66, 0x6b, 0x75, 0xb3, 1516 | 0x92, 0xc8, 0xe9, 0xc1, 0xd2, 0x41, 0x27, 0xb2]), 1517 | bytes([0x16, 0x8e, 0xae, 0xd7, 0xab, 0x38, 0x36, 0x85, 1518 | 0xd6, 0x3c, 0x27, 0x18, 0x92, 0x2b, 0xa8, 0x0a, 1519 | 0x7e, 0xf1, 0x5b, 0xac, 0x39, 0xa6, 0x58, 0x9e, 1520 | 0x1f, 0xa1, 0xdd, 0xa4, 0xdb, 0xb3, 0xc0, 0x51]), 1521 | bytes([0x24, 0x76, 0xfc, 0xac, 0x23, 0x54, 0xe2, 0xee, 1522 | 0x06, 0xc9, 0x44, 0x9a, 0x3c, 0xb4, 0xf8, 0x4f, 1523 | 0x01, 0x30, 0x05, 0x11, 0x27, 0x56, 0x07, 0x58, 1524 | 0x20, 0x74, 0x6d, 0xde, 0x9b, 0x1b, 0x7f, 0xac]), 1525 | bytes([0xe8, 0x67, 0x5d, 0x5a, 0xfb, 0x33, 0x37, 0xa9, 1526 | 0xcc, 0x67, 0xfd, 0x05, 0xe6, 0xff, 0xaf, 0x4f, 1527 | 0x03, 0xaa, 0x98, 0xf5, 0x20, 0xcd, 0x01, 0x2f, 1528 | 0x3f, 0xd0, 0x85, 0x95, 0x57, 0x7a, 0xce, 0xf3]), 1529 | bytes([0xa8, 0xef, 0x68, 0x59, 0xb3, 0xd6, 0xf5, 0x36, 1530 | 0x2d, 0xdc, 0x56, 0x3b, 0xc3, 0x8b, 0x81, 0x9d, 1531 | 0xdf, 0x07, 0xb5, 0xa9, 0x5a, 0x7a, 0x5a, 0xbf, 1532 | 0x8f, 0xbd, 0x2b, 0xbc, 0x72, 0xac, 0x6a, 0xa6]), 1533 | bytes([0xec, 0x2b, 0x46, 0xa6, 0xc8, 0xad, 0x73, 0x26, 1534 | 0x31, 0xc9, 0x8f, 0x83, 0xad, 0x05, 0xae, 0x76, 1535 | 0x73, 0x3c, 0x5e, 0xd4, 0xa8, 0x96, 0xd9, 0xd3, 1536 | 0xd4, 0x13, 0x8b, 0xf4, 0xfb, 0x52, 0x67, 0xa0])]), 1537 | (bytes([0x42, 0x29, 0xb6, 0x23, 0x24, 0xd4, 0x5a, 0x84, 1538 | 0xad, 0xc9, 0x1a, 0xc6, 0xa2, 0x9c, 0x01, 0x85, 1539 | 0x50, 0x11, 0xe5, 0x9f, 0xff, 0x0e, 0xee, 0xc9, 1540 | 0x97, 0xe8, 0x8c, 0xc0, 0x13, 0x9c, 0x86, 0xe9]), 1541 | [bytes([0x8e, 0xd3, 0xc6, 0x76, 0xa2, 0x54, 0xe3, 0x9d, 1542 | 0x94, 0x45, 0xe7, 0x69, 0xfa, 0x54, 0xda, 0xf2, 1543 | 0x1d, 0x6f, 0xa4, 0xa8, 0x6e, 0x7d, 0xc2, 0x3e, 1544 | 0xf3, 0x85, 0xee, 0xea, 0xec, 0x58, 0x48, 0xb4]), 1545 | bytes([0x0f, 0x34, 0x49, 0x52, 0x01, 0x55, 0xbe, 0x5d, 1546 | 0x70, 0xbc, 0x48, 0x0a, 0x59, 0xa5, 0x8a, 0xa4, 1547 | 0x58, 0x7e, 0x03, 0xde, 0x79, 0xf2, 0xbd, 0xee, 1548 | 0xcc, 0x32, 0xea, 0x04, 0x98, 0xf3, 0x37, 0x70]), 1549 | bytes([0x66, 0x51, 0xbd, 0x19, 0x68, 0x87, 0x55, 0xf5, 1550 | 0xb7, 0xc5, 0xf1, 0x3c, 0xdb, 0xd4, 0x18, 0x96, 1551 | 0xfb, 0x0a, 0xbc, 0x3c, 0x6b, 0x9f, 0x32, 0x39, 1552 | 0xaf, 0x4c, 0x2c, 0xda, 0x6e, 0xeb, 0xa8, 0x56]), 1553 | bytes([0xbb, 0x35, 0x81, 0x63, 0xda, 0x48, 0xf4, 0x93, 1554 | 0xde, 0xff, 0xb3, 0x42, 0xc0, 0xad, 0x27, 0xed, 1555 | 0x82, 0x47, 0x10, 0x3a, 0xe0, 0x4e, 0x6a, 0x36, 1556 | 0xc7, 0xcc, 0xec, 0xec, 0x7c, 0x80, 0xb4, 0x4d]), 1557 | bytes([0xeb, 0xef, 0x23, 0xaa, 0x26, 0xb6, 0x1f, 0x6c, 1558 | 0xc1, 0x87, 0xbd, 0x25, 0x1e, 0x9f, 0xe6, 0x68, 1559 | 0xc0, 0x3a, 0xb1, 0x9c, 0xb9, 0x05, 0x5e, 0x54, 1560 | 0xb0, 0xa8, 0xa6, 0x4e, 0x4d, 0x3f, 0xaa, 0x53]), 1561 | bytes([0x80, 0x96, 0xdc, 0x5d, 0x00, 0x50, 0xbb, 0x26, 1562 | 0x92, 0x85, 0xa8, 0x52, 0x4a, 0xd8, 0x2f, 0x0d, 1563 | 0xd2, 0x8b, 0x08, 0xb6, 0xe2, 0x75, 0x76, 0x9a, 1564 | 0x82, 0xcd, 0x65, 0x74, 0x1a, 0x72, 0x86, 0xce]), 1565 | bytes([0x3e, 0x90, 0xb9, 0xf1, 0x6b, 0xb8, 0xb4, 0x67, 1566 | 0x38, 0x52, 0x78, 0xd1, 0xef, 0xfa, 0x2b, 0x9c, 1567 | 0x46, 0xeb, 0xa2, 0xee, 0x3e, 0xdc, 0xc1, 0x67, 1568 | 0xb3, 0x8c, 0x54, 0xa4, 0x26, 0x24, 0xba, 0x9a]), 1569 | bytes([0x3a, 0xcf, 0x25, 0x81, 0x9a, 0x79, 0x3b, 0xf7, 1570 | 0x07, 0xe0, 0xa3, 0x37, 0x94, 0x91, 0x57, 0x8e, 1571 | 0x57, 0x74, 0xce, 0x9a, 0x35, 0xa3, 0x57, 0xd8, 1572 | 0x6e, 0x4a, 0xb9, 0xa2, 0x49, 0x13, 0xf3, 0xf1]), 1573 | bytes([0xeb, 0xf5, 0x6c, 0x0a, 0x89, 0x69, 0x9e, 0x84, 1574 | 0x9f, 0x62, 0x74, 0x4f, 0xed, 0xf9, 0x23, 0x3c, 1575 | 0xa4, 0x7e, 0x03, 0xc8, 0xf5, 0x1a, 0x7f, 0xc5, 1576 | 0x08, 0x73, 0x84, 0x34, 0xa9, 0x2a, 0x8a, 0xe8]), 1577 | bytes([0xa3, 0xe4, 0xc8, 0xee, 0x92, 0x49, 0xdb, 0x9c, 1578 | 0xed, 0xa5, 0x00, 0xec, 0xac, 0x00, 0xe2, 0xb2, 1579 | 0x30, 0x4b, 0x8f, 0x6f, 0x74, 0x55, 0xf5, 0xf9, 1580 | 0xc0, 0xf4, 0x43, 0x30, 0x65, 0x6f, 0x58, 0xc2])]), 1581 | (bytes([0x00, 0xbe, 0xaa, 0xf2, 0x56, 0x95, 0x10, 0x22, 1582 | 0x47, 0x24, 0xec, 0x4a, 0xb3, 0xf8, 0xf9, 0xec, 1583 | 0x10, 0x2c, 0x9a, 0x68, 0x87, 0x37, 0x3b, 0x59, 1584 | 0xf3, 0x27, 0x67, 0x6a, 0xdf, 0x15, 0x4f, 0x91]), 1585 | [bytes([0x79, 0x47, 0x1f, 0x69, 0x8d, 0xc3, 0xe0, 0xe9, 1586 | 0x1a, 0x70, 0x2f, 0x98, 0xb5, 0x28, 0xcf, 0x20, 1587 | 0xfe, 0x86, 0x45, 0xe8, 0xfd, 0xef, 0xd4, 0xc8, 1588 | 0x22, 0xa0, 0xc1, 0x44, 0xe4, 0x36, 0x82, 0xe8]), 1589 | bytes([0x99, 0xaa, 0xf5, 0x66, 0xaf, 0x12, 0xc6, 0x05, 1590 | 0x3c, 0xf9, 0x45, 0x3d, 0x89, 0xea, 0xaf, 0x25, 1591 | 0x19, 0x54, 0xc1, 0xf4, 0x9b, 0xac, 0x0b, 0x64, 1592 | 0xe9, 0x20, 0x0d, 0x4b, 0x78, 0x15, 0x28, 0xb7]), 1593 | bytes([0xc7, 0x82, 0xbe, 0xc3, 0x32, 0x32, 0x41, 0xa3, 1594 | 0x87, 0x05, 0xa2, 0xb4, 0x4d, 0x47, 0x5e, 0xf2, 1595 | 0xc2, 0x7d, 0xbe, 0xfe, 0x9d, 0x2f, 0x0d, 0x25, 1596 | 0xf8, 0x95, 0x57, 0xb8, 0x70, 0xb2, 0xa1, 0x39]), 1597 | bytes([0x29, 0x70, 0xff, 0xac, 0xa3, 0x56, 0x78, 0x8c, 1598 | 0x58, 0xcd, 0x63, 0xb7, 0xba, 0x6e, 0x79, 0x7c, 1599 | 0x63, 0x5e, 0x50, 0xf5, 0x7f, 0x87, 0xcb, 0x2c, 1600 | 0x23, 0xda, 0x27, 0xa4, 0xcc, 0xc9, 0x1e, 0x58]), 1601 | bytes([0x6c, 0x73, 0x83, 0x94, 0xad, 0x22, 0xd9, 0x4c, 1602 | 0x94, 0xc1, 0x0c, 0xf8, 0x58, 0x3e, 0xd3, 0x5f, 1603 | 0xe8, 0x81, 0x18, 0xe7, 0x54, 0x33, 0x3f, 0x9d, 1604 | 0xba, 0x08, 0xd0, 0x38, 0x0d, 0x1a, 0x3a, 0xed]), 1605 | bytes([0x39, 0x15, 0x65, 0x7c, 0x62, 0x2e, 0xed, 0x7c, 1606 | 0xa1, 0xd6, 0x5c, 0x9b, 0x42, 0x67, 0x24, 0x26, 1607 | 0x7a, 0x16, 0x91, 0x32, 0xbd, 0xc5, 0x9e, 0xc3, 1608 | 0x3e, 0x01, 0xab, 0x78, 0xd6, 0x35, 0xaa, 0xd1]), 1609 | bytes([0x13, 0x71, 0xcc, 0xa8, 0x62, 0xd9, 0x8f, 0xb8, 1610 | 0x51, 0x44, 0x69, 0xfd, 0x83, 0xdb, 0x6f, 0xa0, 1611 | 0x00, 0xb3, 0xd0, 0xd4, 0x28, 0x48, 0x22, 0x59, 1612 | 0x85, 0x4a, 0xa3, 0x92, 0xec, 0x01, 0xa8, 0xcc]), 1613 | bytes([0x89, 0x16, 0xb9, 0xe3, 0x54, 0x78, 0x74, 0x15, 1614 | 0x1b, 0xb2, 0x3c, 0x59, 0x20, 0x16, 0xb0, 0x78, 1615 | 0xae, 0x11, 0x43, 0x44, 0x3a, 0x14, 0x8c, 0x6d, 1616 | 0x7f, 0x25, 0xef, 0x6c, 0x91, 0xbf, 0x8d, 0xef]), 1617 | bytes([0x89, 0x87, 0x0d, 0xfb, 0x8d, 0x2a, 0x65, 0x51, 1618 | 0x57, 0x41, 0xfd, 0xbe, 0x7f, 0x10, 0xc9, 0xb1, 1619 | 0xb2, 0x23, 0xc7, 0xb9, 0x3e, 0xc5, 0xbd, 0x1f, 1620 | 0x1d, 0x72, 0xa3, 0x46, 0xf4, 0x20, 0x65, 0xf5]), 1621 | bytes([0xab, 0xc0, 0x50, 0x6f, 0x0b, 0x42, 0x66, 0x9a, 1622 | 0x60, 0xe6, 0x08, 0x0f, 0x47, 0x62, 0x41, 0x60, 1623 | 0x83, 0x05, 0x87, 0x0b, 0x0c, 0x26, 0x38, 0x60, 1624 | 0xac, 0xf6, 0x6a, 0xe7, 0x82, 0x96, 0xf1, 0xb1])]), 1625 | (bytes([0xf7, 0xc1, 0x79, 0x6a, 0xfc, 0xff, 0xb2, 0xfa, 1626 | 0x1b, 0xb6, 0x34, 0xd1, 0x82, 0xe9, 0x11, 0x20, 1627 | 0xb0, 0xfd, 0xe2, 0x3d, 0x14, 0x91, 0x45, 0xc7, 1628 | 0x75, 0xfd, 0x00, 0x83, 0x45, 0x26, 0x5d, 0x78]), 1629 | [bytes([0xc5, 0x4e, 0x43, 0x6f, 0xc2, 0xb2, 0xfa, 0x5f, 1630 | 0xa5, 0xad, 0x86, 0xee, 0x2a, 0x21, 0xd8, 0x0b, 1631 | 0x75, 0x5c, 0x06, 0xe9, 0x73, 0xe2, 0xdc, 0xd4, 1632 | 0x10, 0x33, 0x87, 0xba, 0x51, 0xd2, 0x2a, 0x37]), 1633 | bytes([0x13, 0xb1, 0x6d, 0x2d, 0x3c, 0x4a, 0xb2, 0x64, 1634 | 0xc8, 0x47, 0x7a, 0x5a, 0x5a, 0xbc, 0x56, 0x71, 1635 | 0x28, 0x82, 0x82, 0xa7, 0x07, 0xed, 0xb3, 0xad, 1636 | 0x55, 0xdf, 0x8e, 0xca, 0x11, 0xb4, 0xa4, 0xfa]), 1637 | bytes([0x13, 0x75, 0xe0, 0x66, 0xdb, 0x69, 0xd2, 0xd2, 1638 | 0x9c, 0x67, 0xb1, 0xec, 0xcf, 0x39, 0x84, 0xa1, 1639 | 0xc0, 0x9e, 0x53, 0xc5, 0xc9, 0xb4, 0x15, 0xc7, 1640 | 0xd1, 0xdb, 0x14, 0x0d, 0x8e, 0x50, 0xda, 0xb7]), 1641 | bytes([0x9a, 0xe6, 0x24, 0xb0, 0x7d, 0x77, 0x9b, 0x48, 1642 | 0x3b, 0xa6, 0x02, 0x66, 0x96, 0xd2, 0x86, 0x1d, 1643 | 0x06, 0xb3, 0x7c, 0x2f, 0xdb, 0x50, 0x81, 0x60, 1644 | 0x8a, 0x26, 0x01, 0x7a, 0x1b, 0x25, 0x48, 0x18]), 1645 | bytes([0x92, 0x84, 0xd6, 0xe2, 0xc3, 0x4f, 0xe7, 0xfd, 1646 | 0x1c, 0x5f, 0xf9, 0x62, 0x4a, 0x69, 0x15, 0xea, 1647 | 0x72, 0x26, 0x11, 0x96, 0x69, 0x8f, 0xaa, 0xb0, 1648 | 0x10, 0x36, 0x9b, 0xd4, 0x52, 0x18, 0x2a, 0xf7]), 1649 | bytes([0x65, 0x0b, 0xae, 0x9b, 0x10, 0x5b, 0x3e, 0x8a, 1650 | 0x00, 0x20, 0x75, 0xeb, 0x52, 0xaa, 0x34, 0x71, 1651 | 0xd2, 0x96, 0x7a, 0x66, 0x6c, 0xa4, 0x3c, 0xbd, 1652 | 0xc8, 0x70, 0x18, 0xfb, 0x34, 0x36, 0xd7, 0x75]), 1653 | bytes([0x21, 0xc9, 0x1c, 0x11, 0x12, 0xb2, 0x24, 0xfd, 1654 | 0xe7, 0x89, 0xd5, 0x43, 0x2d, 0xdc, 0x89, 0x80, 1655 | 0x59, 0x65, 0xf5, 0x64, 0x3f, 0xbb, 0x3c, 0xb6, 1656 | 0x15, 0x11, 0x01, 0xaa, 0x5b, 0x31, 0xbc, 0x9e]), 1657 | bytes([0x1b, 0xdc, 0x75, 0xc3, 0x27, 0xd3, 0x86, 0xf5, 1658 | 0x07, 0xc2, 0xd4, 0x65, 0x52, 0x16, 0x2a, 0x5a, 1659 | 0x01, 0xd6, 0x84, 0xaa, 0xda, 0x93, 0xfc, 0xf0, 1660 | 0xf7, 0x7e, 0x85, 0xdf, 0x19, 0x6c, 0xfe, 0x4c]), 1661 | bytes([0xe4, 0x33, 0xcb, 0xee, 0x21, 0x92, 0x97, 0xe6, 1662 | 0xce, 0x3c, 0x17, 0xeb, 0xba, 0x5a, 0x13, 0x10, 1663 | 0xc3, 0xb7, 0xac, 0x85, 0x6e, 0x7f, 0xd2, 0x92, 1664 | 0xda, 0xae, 0x5b, 0xed, 0x10, 0x53, 0x00, 0x8e]), 1665 | bytes([0xe0, 0xe7, 0x90, 0xf7, 0x06, 0xfd, 0x81, 0x45, 1666 | 0x29, 0x79, 0x6e, 0xab, 0xb7, 0x7a, 0x6d, 0xce, 1667 | 0x5b, 0x60, 0xd6, 0xb2, 0x45, 0x1b, 0xd0, 0x1b, 1668 | 0x3b, 0x0b, 0xc2, 0xaa, 0xa6, 0xeb, 0xaf, 0xd8])]), 1669 | (bytes([0xce, 0x99, 0xab, 0x84, 0x59, 0xa2, 0xa4, 0x3a, 1670 | 0xe6, 0x1c, 0xaf, 0xf1, 0x84, 0x2b, 0x79, 0x8b, 1671 | 0x0f, 0x39, 0x22, 0xdb, 0x55, 0x3d, 0x1b, 0x9d, 1672 | 0x53, 0x68, 0x34, 0xb7, 0x96, 0xc0, 0xe3, 0xf2]), 1673 | [bytes([0x85, 0xd9, 0x2e, 0xaa, 0x79, 0x00, 0xa9, 0x91, 1674 | 0xc2, 0xaa, 0x0b, 0x67, 0x6d, 0x23, 0xb7, 0x2d, 1675 | 0x2c, 0x31, 0x6a, 0x8c, 0x40, 0x6c, 0x87, 0x8d, 1676 | 0x42, 0x84, 0x88, 0x1d, 0xc4, 0x6c, 0x7b, 0x7c]), 1677 | bytes([0x75, 0xc7, 0x8b, 0x5e, 0xd0, 0x60, 0x75, 0x72, 1678 | 0xb0, 0x22, 0xf6, 0xf4, 0xdd, 0x72, 0x1d, 0x24, 1679 | 0x90, 0xd9, 0x48, 0x8e, 0x96, 0x9d, 0xec, 0x30, 1680 | 0x11, 0x8c, 0x3a, 0x13, 0x31, 0x0a, 0x24, 0xb2]), 1681 | bytes([0x94, 0x8c, 0x85, 0x7c, 0x53, 0x13, 0x60, 0x75, 1682 | 0x2c, 0x13, 0xaa, 0xa5, 0xa1, 0xee, 0x07, 0xb7, 1683 | 0xdc, 0x5b, 0x23, 0xe0, 0x5a, 0xe8, 0x56, 0xda, 1684 | 0x4f, 0xf9, 0x3d, 0x0c, 0x5c, 0x78, 0xb4, 0x18]), 1685 | bytes([0x4a, 0xde, 0x6c, 0x00, 0x12, 0x15, 0x6d, 0x74, 1686 | 0xda, 0x34, 0xba, 0x6f, 0xb1, 0x2a, 0xf3, 0x6a, 1687 | 0x55, 0xad, 0xc0, 0x43, 0xdc, 0xf3, 0x68, 0x01, 1688 | 0x6c, 0x26, 0x5f, 0xe3, 0x51, 0x3f, 0xac, 0x69]), 1689 | bytes([0xd0, 0x4e, 0x1c, 0x21, 0x6d, 0x8b, 0x57, 0xf4, 1690 | 0xad, 0x2e, 0xdf, 0x62, 0x45, 0xbf, 0x26, 0x9f, 1691 | 0xb0, 0xc8, 0x5a, 0xfa, 0xfd, 0x16, 0xee, 0x9b, 1692 | 0xaa, 0xfd, 0x6f, 0xd4, 0x0b, 0xad, 0x32, 0x80]), 1693 | bytes([0xdb, 0x62, 0x5c, 0x92, 0x21, 0xf6, 0x24, 0x48, 1694 | 0x79, 0xe0, 0xd7, 0x0c, 0xbd, 0xd7, 0xe2, 0xdf, 1695 | 0xfe, 0x5c, 0x6a, 0xdb, 0xe2, 0x33, 0xb8, 0x2a, 1696 | 0x31, 0x2e, 0x02, 0xed, 0xcd, 0x85, 0x1b, 0xb0]), 1697 | bytes([0x49, 0x0d, 0x92, 0xd8, 0x3a, 0x42, 0x59, 0xa7, 1698 | 0x93, 0x4f, 0x38, 0x41, 0x9d, 0xa7, 0x06, 0x3c, 1699 | 0xde, 0xce, 0xf0, 0x0a, 0x73, 0x77, 0xb7, 0xd8, 1700 | 0xdf, 0x09, 0x47, 0x56, 0xab, 0xcc, 0x59, 0xba]), 1701 | bytes([0x8a, 0x72, 0x0a, 0xf5, 0xb6, 0xb3, 0x09, 0xf9, 1702 | 0x69, 0x69, 0x02, 0x4f, 0x42, 0xa1, 0x54, 0x22, 1703 | 0x6e, 0xa3, 0x22, 0x3e, 0x5f, 0x15, 0x41, 0x58, 1704 | 0x9c, 0x3a, 0xd0, 0x59, 0xd4, 0x02, 0xeb, 0x37]), 1705 | bytes([0xbc, 0x66, 0xa5, 0x69, 0x25, 0x65, 0x15, 0xfc, 1706 | 0x33, 0x01, 0xe9, 0xcd, 0x22, 0x9b, 0xbf, 0xc9, 1707 | 0xf9, 0xc0, 0x24, 0x44, 0xa9, 0x02, 0xaf, 0x17, 1708 | 0x1b, 0x76, 0x36, 0xfa, 0x08, 0x2e, 0xd4, 0x78]), 1709 | bytes([0xd7, 0x87, 0xa7, 0x1d, 0xbe, 0xff, 0xd1, 0x82, 1710 | 0x41, 0xcd, 0x50, 0xda, 0x5f, 0x9a, 0xf6, 0x56, 1711 | 0xa1, 0xdc, 0x01, 0x90, 0x87, 0x5e, 0x12, 0x52, 1712 | 0x09, 0xbf, 0x20, 0x31, 0x39, 0x91, 0x04, 0xf3])])] 1713 | -------------------------------------------------------------------------------- /tests/test_WOTSplus.py: -------------------------------------------------------------------------------- 1 | import os 2 | from WOTSplus import WOTSplus 3 | from SPHINCS import SPHINCS 4 | 5 | 6 | def test_WOTSplus(): 7 | n = 256 8 | m = os.urandom(n // 8) 9 | seed = os.urandom(n // 8) 10 | w = 16 11 | masks = [os.urandom(n // 8) for _ in range(w - 1)] 12 | wots = WOTSplus(n=n, w=w, F=SPHINCS().F, Gl=SPHINCS().Glambda) 13 | pk = wots.keygen(seed, masks) 14 | sig = wots.sign(m, seed, masks) 15 | assert pk == wots.verify(m, sig, masks) 16 | 17 | 18 | def test_WOTSplus_ref(): 19 | """This test-case is derived from the SPHINCS reference implementation""" 20 | n = 256 21 | m = bytes(range(32)) 22 | seed = bytes(range(32, 64)) 23 | w = 16 24 | masks = [bytes(range(i, 32+i)) for i in range(w - 1)] 25 | wots = WOTSplus(n=n, w=w, F=SPHINCS().F, Gl=SPHINCS().Glambda) 26 | pk = wots.keygen(seed, masks) 27 | sig = wots.sign(m, seed, masks) 28 | assert pk == wots.verify(m, sig, masks) 29 | assert sig == [bytes([0x11, 0xD8, 0x5B, 0x22, 0xA5, 0xAB, 0x55, 0x9B, 30 | 0x5D, 0x10, 0x6F, 0xDC, 0x08, 0x25, 0xDE, 0x67, 31 | 0x7C, 0x28, 0x74, 0x0B, 0x05, 0x68, 0x98, 0x99, 32 | 0x4E, 0x14, 0x1A, 0xF4, 0xBF, 0x04, 0x6E, 0x73]), 33 | bytes([0xAD, 0x43, 0x24, 0x33, 0x86, 0x8F, 0xB9, 0x9F, 34 | 0x09, 0xCD, 0xDF, 0x03, 0xE7, 0x0D, 0x5E, 0xDE, 35 | 0xDE, 0xCE, 0x9F, 0x8E, 0xE9, 0x17, 0x39, 0xBF, 36 | 0xF3, 0x12, 0x7E, 0x1D, 0x66, 0x82, 0x80, 0x8F]), 37 | bytes([0xAC, 0x3F, 0x87, 0xCB, 0xAA, 0x4A, 0x31, 0x1D, 38 | 0xE1, 0xA5, 0x9C, 0x1D, 0xBA, 0x2C, 0x05, 0x7E, 39 | 0xCF, 0x13, 0xEE, 0x87, 0x35, 0xBB, 0xDD, 0xA6, 40 | 0xD3, 0x43, 0xD3, 0xCE, 0xC2, 0xB7, 0x3E, 0xE7]), 41 | bytes([0xA6, 0x85, 0x62, 0x12, 0x3F, 0xF2, 0xB2, 0x49, 42 | 0xF0, 0x21, 0x0A, 0x47, 0xCD, 0xE3, 0x6A, 0x89, 43 | 0x32, 0x08, 0x26, 0x91, 0x28, 0x37, 0x14, 0x65, 44 | 0xED, 0x29, 0xF0, 0x54, 0x55, 0x07, 0xE1, 0xB7]), 45 | bytes([0x26, 0x05, 0x52, 0x3F, 0x3B, 0x54, 0xD7, 0x02, 46 | 0x2E, 0xFE, 0x6A, 0xC8, 0xD3, 0xEA, 0xA2, 0xAF, 47 | 0xD8, 0xDD, 0x02, 0x7A, 0xD9, 0xA3, 0x4B, 0x90, 48 | 0x93, 0x26, 0x6F, 0x78, 0x83, 0x98, 0x81, 0xD1]), 49 | bytes([0xAD, 0x46, 0xF2, 0xBD, 0x8F, 0xE9, 0xCB, 0xA4, 50 | 0x5E, 0x1C, 0x06, 0xB6, 0x35, 0x26, 0x89, 0x4E, 51 | 0x1D, 0x79, 0x90, 0xE3, 0x94, 0xDB, 0x34, 0xB5, 52 | 0x0C, 0x4C, 0xBA, 0xA7, 0x59, 0xE6, 0x39, 0x9D]), 53 | bytes([0x89, 0x18, 0xD4, 0xC5, 0x72, 0xB9, 0xB0, 0xDD, 54 | 0xFE, 0x63, 0xAD, 0xD3, 0xCC, 0xB0, 0xFC, 0xD9, 55 | 0x21, 0x13, 0x96, 0x0C, 0x1B, 0x0F, 0xDA, 0xD3, 56 | 0xC7, 0x06, 0x71, 0x4C, 0x8E, 0xB3, 0x1F, 0x20]), 57 | bytes([0xB2, 0xBF, 0x3A, 0x65, 0x25, 0xF0, 0x2F, 0xE5, 58 | 0x98, 0x53, 0xC9, 0xED, 0x4D, 0xAE, 0x02, 0x7B, 59 | 0x1B, 0x20, 0x81, 0x15, 0x79, 0xEE, 0x6D, 0x1C, 60 | 0x2C, 0xF4, 0xDE, 0x23, 0xE7, 0x0D, 0x9B, 0x09]), 61 | bytes([0xDD, 0xC5, 0x9B, 0x98, 0x54, 0x74, 0xC0, 0x7C, 62 | 0xF1, 0x42, 0xEF, 0x97, 0x45, 0x00, 0x57, 0x89, 63 | 0xDF, 0x62, 0x04, 0x2A, 0xB7, 0x05, 0xD8, 0x2B, 64 | 0x9B, 0x32, 0x9E, 0x13, 0xAB, 0x3F, 0x60, 0x7C]), 65 | bytes([0xD7, 0x62, 0xD7, 0x42, 0x92, 0x13, 0x15, 0x2F, 66 | 0xC7, 0x2E, 0xC4, 0x16, 0x4C, 0x4A, 0x20, 0x30, 67 | 0x50, 0xF7, 0x81, 0x2A, 0x60, 0x9E, 0x50, 0xFF, 68 | 0xDE, 0x0E, 0x9F, 0x57, 0xB3, 0xBB, 0xC6, 0xE2]), 69 | bytes([0x79, 0x61, 0xA7, 0xD7, 0x22, 0x00, 0x40, 0x3A, 70 | 0x3B, 0x4C, 0x70, 0x33, 0x15, 0x2D, 0xB0, 0x09, 71 | 0x9C, 0x46, 0xEF, 0xEF, 0xEB, 0xA9, 0x42, 0x9D, 72 | 0xCC, 0xA8, 0x0E, 0x13, 0xD4, 0xC5, 0x06, 0x5F]), 73 | bytes([0x44, 0xAB, 0xEF, 0x27, 0x43, 0xCE, 0xC1, 0xDC, 74 | 0xF2, 0x0A, 0xDE, 0x53, 0x82, 0x12, 0xE7, 0x37, 75 | 0xBA, 0x0A, 0xC7, 0xCF, 0xAC, 0x2B, 0x39, 0x08, 76 | 0xC2, 0x92, 0x76, 0xDB, 0x08, 0x8D, 0x4A, 0x4F]), 77 | bytes([0x0C, 0x3D, 0x04, 0x7B, 0x76, 0xE3, 0x30, 0xA5, 78 | 0x71, 0x49, 0x56, 0xB3, 0xB6, 0xF9, 0x9F, 0x9E, 79 | 0xE1, 0xC1, 0x84, 0xB5, 0xB5, 0xB3, 0xF9, 0xFC, 80 | 0xBC, 0x4D, 0xC8, 0x78, 0xA5, 0x99, 0x20, 0x54]), 81 | bytes([0x76, 0x89, 0x21, 0xFC, 0x2B, 0x08, 0xF6, 0x50, 82 | 0x7D, 0x44, 0x29, 0x40, 0xF1, 0xDA, 0x5A, 0x3F, 83 | 0xEC, 0x11, 0xAE, 0x00, 0x07, 0x7A, 0x6C, 0x73, 84 | 0xF2, 0xD8, 0x92, 0x09, 0x7F, 0xF5, 0x95, 0x94]), 85 | bytes([0xD4, 0x53, 0x75, 0x89, 0xCF, 0xF3, 0x5D, 0x10, 86 | 0xD9, 0x8F, 0x5D, 0x9A, 0x39, 0xEB, 0x44, 0x6C, 87 | 0x21, 0x46, 0xA7, 0xF6, 0x54, 0xC3, 0xE7, 0xDE, 88 | 0x6A, 0x1D, 0x9F, 0x6D, 0xA5, 0x24, 0xA0, 0xB5]), 89 | bytes([0xA8, 0x47, 0x1B, 0x7C, 0xF9, 0x70, 0x8E, 0x8E, 90 | 0x57, 0x10, 0x93, 0x33, 0xF0, 0x50, 0x60, 0xCF, 91 | 0x3D, 0xE9, 0x3C, 0xCF, 0x5B, 0x42, 0x39, 0x75, 92 | 0x64, 0xD1, 0xA5, 0x09, 0x8C, 0xBA, 0xD2, 0x5E]), 93 | bytes([0x07, 0x11, 0xA9, 0x75, 0x19, 0xEA, 0x9C, 0x02, 94 | 0xC4, 0xFC, 0xBF, 0x12, 0xD2, 0x74, 0xF6, 0x22, 95 | 0xF6, 0x56, 0xE5, 0x9B, 0x86, 0x66, 0xE2, 0x20, 96 | 0xDE, 0xCD, 0xE8, 0x4E, 0x20, 0xC1, 0x04, 0x50]), 97 | bytes([0x99, 0x52, 0xFD, 0x64, 0x4E, 0x01, 0xC7, 0xB4, 98 | 0x76, 0xF6, 0xBC, 0xD3, 0x81, 0xDA, 0xA1, 0x82, 99 | 0x7D, 0xEE, 0x01, 0x98, 0x80, 0x98, 0xED, 0x3E, 100 | 0xC8, 0xB2, 0xC3, 0x39, 0xF6, 0x1A, 0xF1, 0xA6]), 101 | bytes([0x5B, 0x43, 0x17, 0x14, 0x35, 0xCD, 0x8F, 0x4D, 102 | 0xF0, 0x5C, 0x3D, 0x57, 0xD0, 0x41, 0x6C, 0xB2, 103 | 0x61, 0xB6, 0x17, 0xF2, 0xE9, 0xE6, 0x46, 0x4E, 104 | 0x92, 0xCD, 0x49, 0x96, 0x3D, 0x55, 0x1D, 0xFE]), 105 | bytes([0xFA, 0x17, 0xE0, 0x74, 0xD1, 0x70, 0x61, 0x52, 106 | 0xB9, 0x7C, 0xB8, 0x23, 0x4B, 0x67, 0x69, 0xBA, 107 | 0x7B, 0x8F, 0xCA, 0x69, 0x2A, 0x8E, 0x8B, 0x4F, 108 | 0x99, 0xEF, 0x51, 0x5A, 0x90, 0x48, 0x3A, 0x9A]), 109 | bytes([0x3D, 0x6B, 0x23, 0x8F, 0xE0, 0xEE, 0xB5, 0x1C, 110 | 0x5D, 0x38, 0x14, 0x98, 0x09, 0xF3, 0x1B, 0xBF, 111 | 0xFE, 0x17, 0xC8, 0xB1, 0x8E, 0x20, 0xC5, 0x5D, 112 | 0xF4, 0xB1, 0x19, 0x36, 0x18, 0x2C, 0xE0, 0xBE]), 113 | bytes([0x7C, 0x74, 0xD6, 0x2A, 0x3D, 0x8D, 0xF3, 0x35, 114 | 0x5A, 0xFD, 0xBB, 0x95, 0x4F, 0xF2, 0x7A, 0xAA, 115 | 0x5D, 0xCE, 0x50, 0x2B, 0x52, 0xBE, 0xF6, 0x98, 116 | 0x71, 0x8A, 0x16, 0xEB, 0xD6, 0xAD, 0x03, 0x0D]), 117 | bytes([0xE3, 0x64, 0x01, 0x35, 0xB6, 0x81, 0x9E, 0xB2, 118 | 0xE0, 0x41, 0x0A, 0xBA, 0xCD, 0x14, 0x29, 0xED, 119 | 0xB8, 0x94, 0x3C, 0x6D, 0x2D, 0x63, 0x21, 0x16, 120 | 0x18, 0x9A, 0x2F, 0x50, 0x7B, 0x0D, 0xE8, 0x9F]), 121 | bytes([0x70, 0xD6, 0x41, 0x70, 0xAF, 0x00, 0x83, 0x0A, 122 | 0x46, 0x9E, 0xCD, 0x86, 0xA4, 0xE2, 0xBE, 0xEA, 123 | 0xCD, 0x9F, 0xB9, 0x91, 0x14, 0x89, 0xED, 0x4E, 124 | 0x63, 0x60, 0x7E, 0x09, 0xEA, 0xB3, 0x73, 0x8D]), 125 | bytes([0xDF, 0x04, 0x52, 0x09, 0x59, 0xD6, 0x26, 0xAE, 126 | 0x6E, 0xDD, 0xCF, 0x32, 0xDF, 0x8E, 0x08, 0x28, 127 | 0xA4, 0x45, 0x19, 0x3C, 0xFE, 0xAF, 0x1F, 0xA8, 128 | 0x9B, 0x99, 0x3C, 0xD3, 0x9F, 0x01, 0x02, 0x9A]), 129 | bytes([0x47, 0x3C, 0x4A, 0xE6, 0x41, 0x0B, 0xFB, 0x91, 130 | 0xAE, 0xF5, 0xA9, 0xA1, 0x19, 0x01, 0xB1, 0x2D, 131 | 0xBB, 0xDA, 0xB7, 0x09, 0x33, 0xE6, 0x0D, 0x00, 132 | 0xD1, 0xA1, 0x79, 0xC3, 0xA3, 0xFB, 0x26, 0x05]), 133 | bytes([0x31, 0x7F, 0x64, 0x5A, 0x5B, 0x2D, 0xA6, 0x9D, 134 | 0x76, 0xF9, 0x84, 0x53, 0x3E, 0x77, 0x0A, 0xB8, 135 | 0x91, 0x98, 0x64, 0x8A, 0x15, 0x2A, 0xF6, 0xDA, 136 | 0x23, 0xD0, 0x2E, 0xAF, 0x37, 0x3C, 0xDB, 0xE9]), 137 | bytes([0x60, 0x09, 0xB4, 0x02, 0x5B, 0x3A, 0x3D, 0xB9, 138 | 0xE8, 0x8D, 0x40, 0x62, 0x5A, 0x48, 0xFC, 0x00, 139 | 0x64, 0x1B, 0x1B, 0x4E, 0x31, 0x1D, 0xFD, 0x90, 140 | 0x43, 0xAA, 0x69, 0x9A, 0xBE, 0x18, 0x3F, 0x76]), 141 | bytes([0xB3, 0x4D, 0xED, 0xFF, 0x07, 0x77, 0xE5, 0xAD, 142 | 0xB5, 0x26, 0xC2, 0xF9, 0x2C, 0x57, 0x69, 0x7C, 143 | 0x5C, 0xBC, 0x59, 0x07, 0x18, 0x1A, 0x5F, 0xF3, 144 | 0x05, 0xD9, 0x70, 0x0B, 0x87, 0x65, 0xFF, 0x7D]), 145 | bytes([0x7C, 0x1B, 0xC6, 0x30, 0xF6, 0x45, 0x9D, 0x88, 146 | 0x69, 0xF3, 0x4C, 0xC0, 0x3A, 0xD7, 0xC9, 0xA8, 147 | 0x7D, 0x41, 0xA8, 0x9D, 0x13, 0x50, 0x21, 0xF4, 148 | 0xC4, 0x02, 0xD8, 0xB7, 0x29, 0xB2, 0x8C, 0x5C]), 149 | bytes([0xC3, 0x5F, 0xE3, 0xE7, 0xC2, 0x33, 0x6E, 0x36, 150 | 0x72, 0x85, 0xA2, 0x3B, 0x6E, 0x1D, 0x96, 0x7A, 151 | 0xD6, 0x8A, 0xA7, 0x24, 0x72, 0xAA, 0x1A, 0xB7, 152 | 0x61, 0x90, 0x54, 0x6B, 0x0F, 0xAA, 0x64, 0x24]), 153 | bytes([0xA0, 0xCF, 0x1F, 0xBD, 0x0B, 0x9B, 0xE7, 0xE5, 154 | 0x3E, 0xE7, 0xB4, 0x6E, 0x54, 0xDA, 0x5F, 0x4D, 155 | 0xA2, 0x78, 0xAE, 0x50, 0xA2, 0x6A, 0x22, 0x60, 156 | 0x34, 0x9C, 0x77, 0xF2, 0xEF, 0x26, 0xF9, 0x14]), 157 | bytes([0x5C, 0x42, 0x0B, 0x50, 0x21, 0xAF, 0x47, 0x02, 158 | 0x49, 0x51, 0x4B, 0xD9, 0x38, 0x74, 0x53, 0x5E, 159 | 0xD3, 0xEB, 0xC5, 0x89, 0x52, 0xCF, 0xA7, 0xD8, 160 | 0x9B, 0x34, 0x58, 0x62, 0x37, 0x56, 0x31, 0x75]), 161 | bytes([0x57, 0xBB, 0x89, 0x88, 0xC8, 0x52, 0xEA, 0xB4, 162 | 0xF4, 0xF6, 0x4C, 0xAF, 0x87, 0xFF, 0xA2, 0xA4, 163 | 0x80, 0x4E, 0x12, 0xE1, 0x2B, 0xE6, 0xCB, 0xE5, 164 | 0x65, 0xC5, 0xC7, 0x46, 0x9E, 0x0B, 0xE3, 0x28]), 165 | bytes([0x02, 0x38, 0x6B, 0xCB, 0x64, 0xDA, 0x26, 0xEB, 166 | 0x69, 0xB6, 0x7B, 0xC8, 0xCF, 0xA9, 0xDE, 0xC5, 167 | 0x66, 0x02, 0x98, 0xAF, 0x68, 0xD6, 0x5E, 0x99, 168 | 0xB8, 0xC9, 0xC3, 0xC3, 0x4E, 0x62, 0x9D, 0x26]), 169 | bytes([0x46, 0x5C, 0xCC, 0x08, 0x70, 0x49, 0xCD, 0x00, 170 | 0x12, 0x59, 0xF7, 0x14, 0x12, 0x53, 0x03, 0xA4, 171 | 0x40, 0xD7, 0x3D, 0x0E, 0xC2, 0x79, 0xF1, 0x90, 172 | 0xFB, 0x3B, 0x88, 0x07, 0x13, 0xC9, 0x8A, 0x3C]), 173 | bytes([0x6E, 0xA7, 0x31, 0x5E, 0x36, 0xBB, 0x31, 0xBC, 174 | 0x51, 0x1D, 0xBF, 0x01, 0x96, 0x65, 0x90, 0xA9, 175 | 0x96, 0xF1, 0x1C, 0x2A, 0xE6, 0xEB, 0xAA, 0x97, 176 | 0xC7, 0x61, 0x68, 0xE0, 0x52, 0x82, 0xA3, 0xC5]), 177 | bytes([0x63, 0x09, 0x85, 0xCC, 0x33, 0x86, 0x11, 0xA2, 178 | 0xB4, 0xD3, 0xF0, 0x58, 0xFC, 0x92, 0xDF, 0xB4, 179 | 0x63, 0xBE, 0x67, 0x20, 0x2D, 0x3D, 0xA7, 0x9A, 180 | 0xFA, 0x36, 0xAA, 0x4B, 0xD4, 0x17, 0x8D, 0x07]), 181 | bytes([0xC1, 0x15, 0xEB, 0x3B, 0xD0, 0xAF, 0xE3, 0xEA, 182 | 0xB0, 0x84, 0x68, 0xCF, 0xC5, 0x90, 0xCF, 0x27, 183 | 0x0C, 0x17, 0x38, 0xAC, 0x80, 0x0A, 0x11, 0xBD, 184 | 0x77, 0xB9, 0x7F, 0x95, 0xF1, 0xC6, 0x72, 0xC6]), 185 | bytes([0x77, 0x95, 0xF9, 0x30, 0x58, 0x10, 0x33, 0xC1, 186 | 0x7B, 0x65, 0xFF, 0xB5, 0x76, 0xAB, 0x41, 0xE6, 187 | 0xE1, 0x2A, 0xE9, 0xEF, 0xAF, 0x93, 0xE3, 0xD9, 188 | 0x83, 0x3F, 0x7E, 0xF1, 0x1A, 0x1A, 0x2E, 0xB2]), 189 | bytes([0x04, 0xBF, 0x7D, 0x84, 0x2C, 0xCD, 0x7A, 0x43, 190 | 0x64, 0x7C, 0xB6, 0x8C, 0xB7, 0x03, 0xDB, 0x81, 191 | 0xAE, 0x04, 0xE5, 0xEE, 0x2F, 0x6B, 0x13, 0x74, 192 | 0x00, 0x2C, 0x8E, 0xE7, 0x97, 0x17, 0x3A, 0x12]), 193 | bytes([0xDC, 0xF2, 0xA1, 0xAA, 0xA9, 0xE1, 0x14, 0xF9, 194 | 0x3A, 0x55, 0xE1, 0xF2, 0x75, 0xB9, 0xC2, 0x37, 195 | 0xA9, 0x6C, 0x36, 0x2D, 0x47, 0xBC, 0xFF, 0x22, 196 | 0x2C, 0xFC, 0xDF, 0x83, 0x73, 0x09, 0x5D, 0x8A]), 197 | bytes([0x55, 0x5C, 0xDA, 0x71, 0x22, 0x0B, 0x66, 0x54, 198 | 0xF9, 0x95, 0x73, 0xC4, 0xF4, 0x75, 0xC7, 0x9E, 199 | 0x43, 0xFB, 0x41, 0xFD, 0xC2, 0x25, 0xB5, 0xA7, 200 | 0xD4, 0x07, 0xAC, 0xBF, 0xBF, 0x88, 0xBB, 0x79]), 201 | bytes([0xCE, 0x7E, 0x1C, 0xA5, 0x43, 0x9C, 0xFF, 0x25, 202 | 0x65, 0xC2, 0x31, 0x22, 0x40, 0x07, 0xCF, 0x00, 203 | 0xA3, 0x6B, 0x86, 0x6F, 0xB8, 0x48, 0x8B, 0x11, 204 | 0xA5, 0xAC, 0x19, 0x69, 0x8C, 0x8D, 0x66, 0xC5]), 205 | bytes([0xA2, 0xDF, 0x74, 0x94, 0xA6, 0x1E, 0x73, 0x14, 206 | 0xB1, 0xD3, 0x4F, 0xDD, 0x1A, 0xF8, 0xF1, 0x4F, 207 | 0x01, 0x66, 0x1A, 0x63, 0xF7, 0x15, 0xDD, 0x05, 208 | 0x6C, 0xD6, 0xE8, 0xC8, 0xBD, 0xDD, 0xB7, 0x30]), 209 | bytes([0x6F, 0x1B, 0xDD, 0xF8, 0xF0, 0x87, 0x2E, 0xE8, 210 | 0x25, 0x1D, 0x7A, 0x7E, 0x95, 0x6D, 0xA8, 0x9A, 211 | 0x26, 0x4F, 0xCE, 0x8D, 0x0D, 0x38, 0xFB, 0x11, 212 | 0x96, 0x90, 0x56, 0x7E, 0x6F, 0x47, 0x43, 0x80]), 213 | bytes([0x71, 0xCD, 0x2A, 0xDB, 0x3A, 0x0A, 0x29, 0xD1, 214 | 0xC2, 0xD9, 0x33, 0x64, 0xDC, 0x6D, 0x82, 0x5A, 215 | 0x8F, 0x69, 0x99, 0x88, 0xBF, 0x9E, 0xBA, 0xC5, 216 | 0x97, 0x13, 0xA4, 0xD1, 0x3D, 0xCB, 0x85, 0x34]), 217 | bytes([0xAC, 0xAA, 0x9F, 0x1D, 0xD7, 0xE4, 0xC0, 0x59, 218 | 0xC7, 0xD6, 0xC4, 0xAE, 0xB7, 0x1F, 0x87, 0x52, 219 | 0xDB, 0x7E, 0xB2, 0xED, 0x93, 0xB2, 0x11, 0x73, 220 | 0x3B, 0x94, 0x45, 0xCB, 0xF2, 0xE3, 0xD8, 0xF7]), 221 | bytes([0xFA, 0x3F, 0x55, 0x92, 0x6F, 0xDA, 0x24, 0x2A, 222 | 0xE5, 0x20, 0x00, 0x63, 0xCA, 0xAC, 0x73, 0x66, 223 | 0x65, 0x81, 0xE5, 0x9D, 0x2C, 0xEB, 0xF5, 0xBB, 224 | 0xA9, 0x2E, 0x8B, 0xA4, 0x55, 0x4F, 0xE4, 0x70]), 225 | bytes([0x45, 0xE9, 0xA6, 0x9E, 0x95, 0x1A, 0x21, 0x31, 226 | 0xF2, 0xE0, 0x27, 0xE1, 0xC7, 0xE8, 0xC9, 0xE2, 227 | 0xFE, 0x05, 0x7C, 0x7A, 0x10, 0x82, 0x29, 0xA5, 228 | 0x22, 0x5E, 0xD0, 0x21, 0xCA, 0x89, 0xC6, 0xEB]), 229 | bytes([0xAD, 0x62, 0xAB, 0x67, 0x46, 0x05, 0x20, 0x7E, 230 | 0x82, 0xFF, 0x9D, 0xD9, 0x6F, 0x47, 0xF2, 0x53, 231 | 0x46, 0x9D, 0x08, 0x44, 0xB4, 0x73, 0x35, 0x5A, 232 | 0x2A, 0xF4, 0x54, 0xCD, 0xAE, 0x6A, 0xA2, 0x97]), 233 | bytes([0xD1, 0x1D, 0x65, 0xF6, 0x64, 0x68, 0x3E, 0x3E, 234 | 0xC5, 0x10, 0x9D, 0x24, 0x06, 0xD4, 0xCC, 0x8F, 235 | 0x63, 0x06, 0xF4, 0xD7, 0x22, 0x0C, 0x44, 0xEB, 236 | 0xDE, 0x0E, 0x6C, 0xDA, 0xA5, 0x04, 0xDE, 0x13]), 237 | bytes([0x63, 0x2F, 0x27, 0x19, 0xBE, 0x41, 0x2B, 0xA6, 238 | 0xA8, 0x60, 0xDF, 0x7D, 0x08, 0xE6, 0x6B, 0x82, 239 | 0xC3, 0xD0, 0xE3, 0x30, 0x3D, 0xEF, 0x0E, 0x43, 240 | 0x1F, 0x64, 0xDF, 0xB7, 0xBA, 0xA7, 0x0A, 0x3D]), 241 | bytes([0x66, 0x05, 0xE1, 0x74, 0xF1, 0xD3, 0x70, 0xDC, 242 | 0x4B, 0x11, 0x51, 0x3F, 0x59, 0xB3, 0x79, 0x94, 243 | 0xF6, 0x2F, 0x24, 0x6A, 0xEC, 0x2E, 0xB0, 0xAB, 244 | 0xE3, 0x29, 0xED, 0xAD, 0xC6, 0x1F, 0x8C, 0x71]), 245 | bytes([0xAF, 0xC4, 0xBA, 0x01, 0x88, 0x88, 0x38, 0x55, 246 | 0x49, 0x6B, 0x5F, 0xBC, 0xA4, 0xF6, 0x53, 0x3A, 247 | 0xDB, 0x35, 0x37, 0xD9, 0xC5, 0x15, 0xC9, 0x56, 248 | 0xC8, 0x43, 0x70, 0x9B, 0xAD, 0x11, 0x6F, 0x97]), 249 | bytes([0xBE, 0x52, 0x0E, 0x4C, 0xA2, 0x48, 0x0D, 0x47, 250 | 0xB2, 0xBD, 0x47, 0x59, 0xCE, 0x62, 0xAD, 0x2D, 251 | 0xC5, 0xF4, 0xF6, 0xB3, 0x2D, 0x0C, 0xAE, 0xB5, 252 | 0x95, 0x47, 0x93, 0xB3, 0x57, 0x01, 0xEE, 0x8E]), 253 | bytes([0xC6, 0xB4, 0x4D, 0xC6, 0x4C, 0xC8, 0x74, 0xD0, 254 | 0x7F, 0x7D, 0x95, 0x51, 0x7B, 0xAD, 0x89, 0x4B, 255 | 0x83, 0x11, 0xFF, 0xCD, 0x1F, 0x65, 0x82, 0xC2, 256 | 0xFC, 0x80, 0xEB, 0xD5, 0x10, 0x7A, 0x8E, 0xA9]), 257 | bytes([0xF2, 0xB3, 0x0D, 0x8A, 0xE0, 0xE5, 0x05, 0x6F, 258 | 0xA2, 0xF2, 0x98, 0xF8, 0xCE, 0xC3, 0x8A, 0x17, 259 | 0xB6, 0x74, 0x5F, 0x16, 0x29, 0x73, 0x56, 0x9F, 260 | 0x91, 0xE3, 0xDA, 0x75, 0x82, 0x61, 0x0E, 0x54]), 261 | bytes([0x05, 0x97, 0x92, 0x5B, 0x1D, 0xFF, 0x2F, 0x9F, 262 | 0xC7, 0x29, 0x3D, 0xA6, 0xAB, 0xC4, 0x86, 0x3D, 263 | 0xD3, 0x16, 0x18, 0xE6, 0x28, 0x18, 0xDD, 0x9C, 264 | 0xCE, 0xE9, 0x38, 0x4F, 0xF6, 0xD1, 0xE7, 0x0E]), 265 | bytes([0xAA, 0x60, 0x49, 0xEA, 0x2E, 0x27, 0xF8, 0xBE, 266 | 0xDE, 0x47, 0xF5, 0x7B, 0x0D, 0x36, 0x9F, 0xCB, 267 | 0xD1, 0xC7, 0xE7, 0xAB, 0x84, 0xED, 0x48, 0x37, 268 | 0x2F, 0x79, 0x2B, 0xE6, 0x85, 0x38, 0x62, 0x78]), 269 | bytes([0xDA, 0x43, 0x5B, 0x2E, 0x83, 0x65, 0x26, 0x67, 270 | 0xE4, 0xD8, 0x25, 0x8F, 0x14, 0x7B, 0x70, 0x41, 271 | 0x0C, 0x51, 0x71, 0xE1, 0x4A, 0x2C, 0x93, 0x72, 272 | 0xBA, 0x3F, 0xDE, 0x6F, 0x53, 0x98, 0x71, 0x10]), 273 | bytes([0xAE, 0x1F, 0x5B, 0x2C, 0xDA, 0x9F, 0xFD, 0x93, 274 | 0x24, 0x9E, 0x83, 0x1A, 0x8D, 0x62, 0x75, 0xAB, 275 | 0x03, 0xC0, 0xE6, 0xB9, 0xF1, 0xC0, 0x3C, 0x08, 276 | 0xCB, 0x1E, 0xC2, 0x35, 0x6E, 0x3C, 0xC7, 0x0D]), 277 | bytes([0x5D, 0xEE, 0x4B, 0xC7, 0x3D, 0xBD, 0xA8, 0xCA, 278 | 0x56, 0xDB, 0x9A, 0x37, 0xC8, 0x3A, 0xCB, 0x60, 279 | 0x2D, 0x45, 0xD7, 0x7B, 0x1E, 0x97, 0x8E, 0x85, 280 | 0x16, 0x36, 0x9A, 0x96, 0x61, 0x73, 0x07, 0xEF]), 281 | bytes([0x4B, 0x67, 0xD3, 0xCF, 0xD2, 0xEF, 0xEC, 0x9E, 282 | 0x64, 0x1E, 0x5D, 0x85, 0x3C, 0x13, 0x23, 0x34, 283 | 0xA7, 0x80, 0x9B, 0xC4, 0x2C, 0x3C, 0xB9, 0xF2, 284 | 0xF7, 0x38, 0x93, 0xDF, 0x3D, 0xFE, 0x65, 0x44]), 285 | bytes([0x82, 0x0F, 0xD1, 0xD7, 0x25, 0x4A, 0xC1, 0x78, 286 | 0x69, 0x74, 0xA0, 0xB5, 0x3A, 0xAD, 0x51, 0xF3, 287 | 0x58, 0x78, 0xBD, 0x5E, 0x18, 0x9B, 0xA7, 0xB4, 288 | 0x82, 0x1A, 0x28, 0xD9, 0x1B, 0xB1, 0x18, 0xBD]), 289 | bytes([0xC4, 0xCE, 0xFC, 0x80, 0x5F, 0x10, 0x83, 0xA9, 290 | 0xE7, 0x9D, 0xB9, 0x03, 0x48, 0x1A, 0x90, 0x44, 291 | 0xDB, 0xB7, 0x06, 0x39, 0xD0, 0x6B, 0x96, 0xFE, 292 | 0x80, 0x71, 0x16, 0x74, 0x31, 0x79, 0x55, 0x35]), 293 | bytes([0xAD, 0x22, 0xB8, 0xB8, 0xC7, 0x2C, 0x5B, 0x9F, 294 | 0x1D, 0x24, 0x9A, 0xD4, 0x1D, 0x48, 0x90, 0x5F, 295 | 0x4F, 0x70, 0x57, 0x1D, 0xF2, 0x2F, 0x8D, 0xAF, 296 | 0xBB, 0x0A, 0xC8, 0x14, 0x09, 0xA8, 0xB0, 0xC5])] 297 | -------------------------------------------------------------------------------- /tests/test_trees.py: -------------------------------------------------------------------------------- 1 | from trees import l_tree, hash_tree, auth_path, construct_root 2 | 3 | 4 | def test_sum_tree(): 5 | sum_tree = list(hash_tree(lambda x, y, i: x + y, range(16))) 6 | assert sum_tree[-1][0] == sum(range(16)) 7 | 8 | 9 | def test_sum_l_tree(): 10 | sum_tree = list(l_tree(lambda x, y, i: x + y, range(20))) 11 | assert sum_tree[-1][0] == sum(range(20)) 12 | 13 | 14 | def test_left_tree(): 15 | min_tree = list(l_tree(lambda x, y, i: x, range(20))) 16 | assert min_tree[-1][0] == min(range(20)) 17 | 18 | 19 | def test_right_tree(): 20 | max_tree = list(l_tree(lambda x, y, i: y, range(20))) 21 | assert max_tree[-1][0] == max(range(20)) 22 | 23 | 24 | def test_auth_path(): 25 | tree = list(hash_tree(lambda x, y, i: x >> 1, range(15, 31))) 26 | assert list(auth_path(tree, 5)) == [19, 10, 3, 2] 27 | 28 | 29 | def test_construct_root(): 30 | H = lambda x, y, i: x - y 31 | minus_tree = list(hash_tree(H, range(16))) 32 | for i in range(16): 33 | leaf = minus_tree[0][i] 34 | path = auth_path(minus_tree, i) 35 | assert construct_root(H, path, leaf, i) == minus_tree[-1][0] 36 | -------------------------------------------------------------------------------- /trees.py: -------------------------------------------------------------------------------- 1 | from math import log2, ceil 2 | 3 | 4 | def hash_tree(H, leafs): 5 | assert (len(leafs) & len(leafs) - 1) == 0 # test for full binary tree 6 | return l_tree(H, leafs) # binary hash trees are special cases of L-Trees 7 | 8 | 9 | def l_tree(H, leafs): 10 | layer = leafs 11 | yield layer 12 | for i in range(ceil(log2(len(leafs)))): 13 | next_layer = [H(l, r, i) for l, r in zip(layer[0::2], layer[1::2])] 14 | if len(layer) & 1: # if there is a node left on this layer 15 | next_layer.append(layer[-1]) 16 | layer = next_layer 17 | yield layer 18 | 19 | 20 | def auth_path(tree, idx): 21 | path = [] 22 | for layer in tree: 23 | if len(layer) == 1: # if there are no neighbors 24 | break 25 | idx += 1 if (idx & 1 == 0) else -1 # neighbor node 26 | path.append(layer[idx]) 27 | idx >>= 1 # parent node 28 | return path 29 | 30 | 31 | def construct_root(H, auth_path, leaf, idx): 32 | node = leaf 33 | for i, neighbor in enumerate(auth_path): 34 | if idx & 1 == 0: 35 | node = H(node, neighbor, i) 36 | else: 37 | node = H(neighbor, node, i) 38 | idx >>= 1 39 | return node 40 | 41 | 42 | def root(tree): 43 | return list(tree)[-1][0] 44 | --------------------------------------------------------------------------------