text
stringlengths 2
104M
| meta
dict |
|---|---|
/*
NORX reference source code package - reference C implementations
Written 2014-2015 by:
- Samuel Neves <[email protected]>
- Philipp Jovanovic <[email protected]>
To the extent possible under law, the author(s) have dedicated all copyright
and related and neighboring rights to this software to the public domain
worldwide. This software is distributed without any warranty.
You should have received a copy of the CC0 Public Domain Dedication along with
this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "norx_util.h"
#include "norx.h"
const char * norx_version = "2.0";
#if NORX_W == 8
#define NORX_N (NORX_W * 4) /* Nonce size */
#define NORX_K (NORX_W * 10) /* Key size */
#define NORX_C (NORX_W * 11) /* Capacity */
#elif NORX_W == 16
#define NORX_N (NORX_W * 2) /* Nonce size */
#define NORX_K (NORX_W * 6) /* Key size */
#define NORX_C (NORX_W * 8) /* Capacity */
#else
#error "Invalid word size."
#endif
#define NORX_B (NORX_W * 16) /* Permutation width */
#define NORX_R (NORX_B - NORX_C) /* Rate */
#if NORX_W == 8 /* NORX8 specific */
#define LOAD load8
#define STORE store8
/* Rotation constants */
#define R0 1
#define R1 3
#define R2 5
#define R3 7
#elif NORX_W == 16 /* NORX16 specific */
#define LOAD load16
#define STORE store16
/* Rotation constants */
#define R0 8
#define R1 11
#define R2 12
#define R3 15
#else
#error "Invalid word size."
#endif
#if defined(NORX_DEBUG)
#include <stdio.h>
#include <inttypes.h>
#if NORX_W == 8
#define NORX_FMT "02" PRIX8
#elif NORX_W == 16
#define NORX_FMT "04" PRIX16
#endif
static void norx_print_state(norx_state_t state)
{
static const char fmt[] = "%" NORX_FMT " "
"%" NORX_FMT " "
"%" NORX_FMT " "
"%" NORX_FMT "\n";
const norx_word_t * S = state->S;
printf(fmt, S[ 0],S[ 1],S[ 2],S[ 3]);
printf(fmt, S[ 4],S[ 5],S[ 6],S[ 7]);
printf(fmt, S[ 8],S[ 9],S[10],S[11]);
printf(fmt, S[12],S[13],S[14],S[15]);
printf("\n");
}
static void print_bytes(const uint8_t *in, size_t inlen)
{
size_t i;
for (i = 0; i < inlen; ++i) {
printf("%02X%c", in[i], i%16 == 15 ? '\n' : ' ');
}
if (inlen%16 != 0) {
printf("\n");
}
}
static void norx_debug(norx_state_t state, const uint8_t *in, size_t inlen, const uint8_t *out, size_t outlen)
{
if (in != NULL && inlen > 0) {
printf("In:\n");
print_bytes(in, inlen);
}
if (out != NULL && outlen > 0) {
printf("Out:\n");
print_bytes(out, outlen);
}
printf("State:\n");
norx_print_state(state);
}
#endif
/* The nonlinear primitive */
#define H(A, B) ( ( (A) ^ (B) ) ^ ( ( (A) & (B) ) << 1) )
/* The quarter-round */
#define G(A, B, C, D) \
do \
{ \
(A) = H(A, B); (D) ^= (A); (D) = ROTR((D), R0); \
(C) = H(C, D); (B) ^= (C); (B) = ROTR((B), R1); \
(A) = H(A, B); (D) ^= (A); (D) = ROTR((D), R2); \
(C) = H(C, D); (B) ^= (C); (B) = ROTR((B), R3); \
} while (0)
/* The full round */
static NORX_INLINE void F(norx_word_t S[16])
{
/* Column step */
G(S[ 0], S[ 4], S[ 8], S[12]);
G(S[ 1], S[ 5], S[ 9], S[13]);
G(S[ 2], S[ 6], S[10], S[14]);
G(S[ 3], S[ 7], S[11], S[15]);
/* Diagonal step */
G(S[ 0], S[ 5], S[10], S[15]);
G(S[ 1], S[ 6], S[11], S[12]);
G(S[ 2], S[ 7], S[ 8], S[13]);
G(S[ 3], S[ 4], S[ 9], S[14]);
}
/* The core permutation */
static NORX_INLINE void norx_permute(norx_state_t state)
{
norx_word_t * S = state->S;
size_t i;
for (i = 0; i < NORX_L; ++i) {
F(S);
}
}
static NORX_INLINE void norx_pad(uint8_t *out, const uint8_t *in, const size_t inlen)
{
memset(out, 0, BYTES(NORX_R));
memcpy(out, in, inlen);
out[inlen] = 0x01;
out[BYTES(NORX_R) - 1] |= 0x80;
}
static NORX_INLINE void norx_absorb_block(norx_state_t state, const uint8_t * in, tag_t tag)
{
size_t i;
norx_word_t * S = state->S;
S[15] ^= tag;
norx_permute(state);
for (i = 0; i < WORDS(NORX_R); ++i) {
S[i] ^= LOAD(in + i * BYTES(NORX_W));
}
}
static NORX_INLINE void norx_absorb_lastblock(norx_state_t state, const uint8_t * in, size_t inlen, tag_t tag)
{
uint8_t lastblock[BYTES(NORX_R)];
norx_pad(lastblock, in, inlen);
norx_absorb_block(state, lastblock, tag);
}
static NORX_INLINE void norx_encrypt_block(norx_state_t state, uint8_t *out, const uint8_t * in)
{
size_t i;
norx_word_t * S = state->S;
S[15] ^= PAYLOAD_TAG;
norx_permute(state);
for (i = 0; i < WORDS(NORX_R); ++i) {
S[i] ^= LOAD(in + i * BYTES(NORX_W));
STORE(out + i * BYTES(NORX_W), S[i]);
}
}
static NORX_INLINE void norx_encrypt_lastblock(norx_state_t state, uint8_t *out, const uint8_t * in, size_t inlen)
{
uint8_t lastblock[BYTES(NORX_R)];
norx_pad(lastblock, in, inlen);
norx_encrypt_block(state, lastblock, lastblock);
memcpy(out, lastblock, inlen);
}
static NORX_INLINE void norx_decrypt_block(norx_state_t state, uint8_t *out, const uint8_t * in)
{
size_t i;
norx_word_t * S = state->S;
S[15] ^= PAYLOAD_TAG;
norx_permute(state);
for (i = 0; i < WORDS(NORX_R); ++i) {
const norx_word_t c = LOAD(in + i * BYTES(NORX_W));
STORE(out + i * BYTES(NORX_W), S[i] ^ c);
S[i] = c;
}
}
static NORX_INLINE void norx_decrypt_lastblock(norx_state_t state, uint8_t *out, const uint8_t * in, size_t inlen)
{
norx_word_t * S = state->S;
uint8_t lastblock[BYTES(NORX_R)];
size_t i;
S[15] ^= PAYLOAD_TAG;
norx_permute(state);
for(i = 0; i < WORDS(NORX_R); ++i) {
STORE(lastblock + i * BYTES(NORX_W), S[i]);
}
memcpy(lastblock, in, inlen);
lastblock[inlen] ^= 0x01;
lastblock[BYTES(NORX_R) - 1] ^= 0x80;
for (i = 0; i < WORDS(NORX_R); ++i) {
const norx_word_t c = LOAD(lastblock + i * BYTES(NORX_W));
STORE(lastblock + i * BYTES(NORX_W), S[i] ^ c);
S[i] = c;
}
memcpy(out, lastblock, inlen);
burn(lastblock, 0, sizeof lastblock);
}
/* Low-level operations */
static NORX_INLINE void norx_init(norx_state_t state, const uint8_t *k, const uint8_t *n)
{
norx_word_t * S = state->S;
size_t i;
for(i = 0; i < WORDS(NORX_B); ++i) {
S[i] = i;
}
F(S);
F(S);
#if NORX_W == 8
S[ 0] = LOAD(n + 0 * BYTES(NORX_W));
S[ 1] = LOAD(n + 1 * BYTES(NORX_W));
S[ 2] = LOAD(n + 2 * BYTES(NORX_W));
S[ 3] = LOAD(n + 3 * BYTES(NORX_W));
S[ 4] = LOAD(k + 0 * BYTES(NORX_W));
S[ 5] = LOAD(k + 1 * BYTES(NORX_W));
S[ 6] = LOAD(k + 2 * BYTES(NORX_W));
S[ 7] = LOAD(k + 3 * BYTES(NORX_W));
S[ 8] = LOAD(k + 4 * BYTES(NORX_W));
S[ 9] = LOAD(k + 5 * BYTES(NORX_W));
S[10] = LOAD(k + 6 * BYTES(NORX_W));
S[11] = LOAD(k + 7 * BYTES(NORX_W));
S[12] = LOAD(k + 8 * BYTES(NORX_W));
S[13] = LOAD(k + 9 * BYTES(NORX_W));
#elif NORX_W == 16
S[ 0] = LOAD(n + 0 * BYTES(NORX_W));
S[ 1] = LOAD(n + 1 * BYTES(NORX_W));
S[ 2] = LOAD(k + 0 * BYTES(NORX_W));
S[ 3] = LOAD(k + 1 * BYTES(NORX_W));
S[ 4] = LOAD(k + 2 * BYTES(NORX_W));
S[ 5] = LOAD(k + 3 * BYTES(NORX_W));
S[ 6] = LOAD(k + 4 * BYTES(NORX_W));
S[ 7] = LOAD(k + 5 * BYTES(NORX_W));
#else
#error "Invalid word size."
#endif
S[12] ^= NORX_W;
S[13] ^= NORX_L;
S[14] ^= NORX_P;
S[15] ^= NORX_T;
norx_permute(state);
#if defined(NORX_DEBUG)
printf("Initialise\n");
norx_debug(state, NULL, 0, NULL, 0);
#endif
}
void norx_absorb_data(norx_state_t state, const unsigned char * in, size_t inlen, tag_t tag)
{
if (inlen > 0)
{
while (inlen >= BYTES(NORX_R))
{
norx_absorb_block(state, in, tag);
#if defined(NORX_DEBUG)
printf("Absorb block\n");
norx_debug(state, in, BYTES(NORX_R), NULL, 0);
#endif
inlen -= BYTES(NORX_R);
in += BYTES(NORX_R);
}
norx_absorb_lastblock(state, in, inlen, tag);
#if defined(NORX_DEBUG)
printf("Absorb lastblock\n");
norx_debug(state, in, inlen, NULL, 0);
#endif
}
}
#if NORX_P == 1
void norx_encrypt_data(norx_state_t state, unsigned char *out, const unsigned char * in, size_t inlen)
{
if (inlen > 0)
{
while (inlen >= BYTES(NORX_R))
{
norx_encrypt_block(state, out, in);
#if defined(NORX_DEBUG)
printf("Encrypt block\n");
norx_debug(state, in, BYTES(NORX_R), out, BYTES(NORX_R));
#endif
inlen -= BYTES(NORX_R);
in += BYTES(NORX_R);
out += BYTES(NORX_R);
}
norx_encrypt_lastblock(state, out, in, inlen);
#if defined(NORX_DEBUG)
printf("Encrypt lastblock\n");
norx_debug(state, in, inlen, out, inlen);
#endif
}
}
void norx_decrypt_data(norx_state_t state, unsigned char *out, const unsigned char * in, size_t inlen)
{
if (inlen > 0)
{
while (inlen >= BYTES(NORX_R))
{
norx_decrypt_block(state, out, in);
#if defined(NORX_DEBUG)
printf("Decrypt block\n");
norx_debug(state, in, BYTES(NORX_R), out, BYTES(NORX_R));
#endif
inlen -= BYTES(NORX_R);
in += BYTES(NORX_R);
out += BYTES(NORX_R);
}
norx_decrypt_lastblock(state, out, in, inlen);
#if defined(NORX_DEBUG)
printf("Decrypt lastblock\n");
norx_debug(state, in, inlen, out, inlen);
#endif
}
}
#else /* NORX8/16 only support sequential encryption/decryption */
#error "NORX_P cannot be != 1"
#endif
static NORX_INLINE void norx_finalise(norx_state_t state, unsigned char * tag)
{
size_t i;
norx_word_t * S = state->S;
uint8_t lastblock[BYTES(NORX_R)];
S[15] ^= FINAL_TAG;
norx_permute(state);
norx_permute(state);
for (i = 0; i < WORDS(NORX_R); ++i) {
STORE(lastblock + i * BYTES(NORX_W), S[i]);
}
#if NORX_W == 8
memcpy(tag, lastblock, BYTES(NORX_R));
S[15] ^= FINAL_TAG;
norx_permute(state);
for (i = 0; i < WORDS(NORX_R); ++i) {
STORE(lastblock + i * BYTES(NORX_W), S[i]);
}
memcpy(tag + BYTES(NORX_R), lastblock, BYTES(NORX_R));
#else /* NORX16 */
memcpy(tag, lastblock, BYTES(NORX_T));
#endif
#if defined(NORX_DEBUG)
printf("Finalise\n");
norx_debug(state, NULL, 0, NULL, 0);
#endif
burn(lastblock, 0, BYTES(NORX_R)); /* burn full state dump */
burn(state, 0, sizeof(norx_state_t)); /* at this point we can also burn the state */
}
/* Verify tags in constant time: 0 for success, -1 for fail */
int norx_verify_tag(const unsigned char * tag1, const unsigned char * tag2)
{
unsigned acc = 0;
size_t i;
for(i = 0; i < BYTES(NORX_N); ++i)
acc |= tag1[i] ^ tag2[i];
return (((acc - 1) >> 8) & 1) - 1;
}
/* High-level operations */
void norx_aead_encrypt(
unsigned char *c, size_t *clen,
const unsigned char *a, size_t alen,
const unsigned char *m, size_t mlen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce,
const unsigned char *key
)
{
norx_state_t state;
norx_init(state, key, nonce);
norx_absorb_data(state, a, alen, HEADER_TAG);
norx_encrypt_data(state, c, m, mlen);
norx_absorb_data(state, z, zlen, TRAILER_TAG);
norx_finalise(state, c + mlen);
*clen = mlen + BYTES(NORX_T);
burn(state, 0, sizeof(norx_state_t));
}
int norx_aead_decrypt(
unsigned char *m, size_t *mlen,
const unsigned char *a, size_t alen,
const unsigned char *c, size_t clen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce,
const unsigned char *key
)
{
int result = -1;
unsigned char tag[BYTES(NORX_T)];
norx_state_t state;
if (clen < BYTES(NORX_T)) {
return -1;
}
norx_init(state, key, nonce);
norx_absorb_data(state, a, alen, HEADER_TAG);
norx_decrypt_data(state, m, c, clen - BYTES(NORX_T));
norx_absorb_data(state, z, zlen, TRAILER_TAG);
norx_finalise(state, tag);
*mlen = clen - BYTES(NORX_T);
result = norx_verify_tag(c + clen - BYTES(NORX_T), tag);
if (result != 0) { /* burn decrypted plaintext on auth failure */
burn(m, 0, clen - BYTES(NORX_T));
}
burn(state, 0, sizeof(norx_state_t));
return result;
}
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
#ifndef NORX_KAT_H
#define NORX_KAT_H
static const unsigned char kat[] =
{
0x9C, 0x89, 0x02, 0x43, 0x8E, 0x99, 0x52, 0x8E,
0xD8, 0x61, 0x28, 0x94, 0x8B, 0xB6, 0x97, 0x2F,
0xF1, 0xA6, 0x77, 0x86, 0x31, 0x36, 0x24, 0x4B,
0x4F, 0x80, 0xE9, 0x2E, 0xD8, 0xF6, 0xB5, 0xAA,
0x58, 0x7D, 0x70, 0xD2, 0x4D, 0x2B, 0x5A, 0x1F,
0x0E, 0xD2, 0x69, 0x99, 0xD2, 0x73, 0x6B, 0xEF,
0x11, 0x1A, 0xDF, 0xDA, 0xD6, 0xA0, 0x3E, 0x9B,
0xF3, 0x65, 0xFC, 0x01, 0x0A, 0x7C, 0x5D, 0xED,
0x03,
0xB6, 0x9D, 0x4B, 0x6C, 0x84, 0x22, 0xBC, 0xB1,
0x45, 0xE8, 0x47, 0x49, 0xA7, 0x98, 0x71, 0x8D,
0x17, 0xE3, 0x5D, 0xF2, 0xFD, 0x7E, 0x7F, 0x52,
0xDD, 0x69, 0x68, 0x0E, 0xC4, 0x27, 0x35, 0xE0,
0xAD, 0x51,
0x53, 0x09, 0x96, 0xDA, 0x0D, 0x88, 0x00, 0x01,
0xD5, 0x4F, 0x99, 0xBF, 0x8B, 0xCD, 0xC1, 0xD3,
0x87, 0x3F, 0x56, 0x67, 0xC7, 0x46, 0x17, 0x67,
0x19, 0x28, 0xCD, 0xF7, 0x2E, 0x1D, 0xC8, 0xC4,
0xE6, 0x11, 0x53,
0x20, 0x7F, 0x82, 0x2B, 0xC1, 0x1E, 0x6A, 0x33,
0x17, 0x27, 0x5A, 0x98, 0xD2, 0x2D, 0x69, 0x3A,
0x97, 0x99, 0xD7, 0x76, 0xDA, 0x58, 0x65, 0x17,
0x4C, 0x36, 0x74, 0xA7, 0x9B, 0xBC, 0xBB, 0xCA,
0x9C, 0xFE, 0x3D, 0x53,
0x04, 0xAF, 0x10, 0xDE, 0x94, 0x7F, 0x91, 0xCC,
0xBE, 0xF0, 0x8C, 0x52, 0x8C, 0xCE, 0xE8, 0xFF,
0x2F, 0x91, 0x98, 0xE4, 0x82, 0x65, 0xD8, 0xB9,
0xB8, 0x1D, 0x36, 0x11, 0xF6, 0xFB, 0xD4, 0x73,
0x8A, 0xDE, 0x23, 0xC7, 0x9A,
0x85, 0xCB, 0x0F, 0x76, 0x18, 0x9E, 0xBF, 0x17,
0xBA, 0x69, 0xA6, 0x65, 0x0E, 0x32, 0x23, 0xA7,
0xFB, 0x73, 0xC4, 0x04, 0x2A, 0xB2, 0xAA, 0xD7,
0xF7, 0x57, 0x92, 0x0E, 0x4F, 0x60, 0x22, 0x06,
0xB5, 0xF5, 0x1E, 0xA8, 0x57, 0x32,
0x09, 0x6C, 0xD3, 0x46, 0xF5, 0x92, 0x65, 0x27,
0x2E, 0xBE, 0x8C, 0x08, 0x16, 0x49, 0x22, 0x88,
0xEF, 0x30, 0x05, 0x81, 0x9C, 0xC1, 0x9A, 0x56,
0x6F, 0xBA, 0x84, 0x3C, 0xB2, 0xCA, 0x00, 0x65,
0x04, 0xBA, 0xE2, 0xFB, 0x30, 0xCC, 0x12,
0x0C, 0xC3, 0xBD, 0x0E, 0x35, 0x70, 0xCF, 0x44,
0xC3, 0x03, 0x2D, 0x57, 0x71, 0xEF, 0xD8, 0xC6,
0x30, 0x49, 0x25, 0x08, 0xEC, 0x69, 0x20, 0x9C,
0x29, 0xCE, 0x91, 0xFC, 0x09, 0x17, 0xD1, 0xFF,
0x97, 0x2F, 0xF3, 0x04, 0x4C, 0x63, 0xA2, 0xAD,
0xC4, 0x11, 0x3E, 0xE5, 0x6A, 0xB5, 0xB6, 0xEE,
0x2B, 0xD4, 0xDC, 0xF3, 0x70, 0x49, 0x89, 0xA1,
0x31, 0x74, 0x87, 0xF4, 0xC3, 0xB0, 0x30, 0xE7,
0xFE, 0x8C, 0x04, 0x8D, 0xEF, 0xA7, 0xA4, 0xA2,
0x1E, 0x39, 0x5B, 0xB7, 0x14, 0x65, 0x90, 0x82,
0x69,
0xC8, 0x9A, 0x4B, 0x76, 0x64, 0x44, 0x51, 0x22,
0xE6, 0xC0, 0x62, 0x33, 0x0F, 0x56, 0x65, 0xEB,
0xEC, 0x66, 0x0A, 0x99, 0x9E, 0x77, 0x4D, 0x3E,
0x7E, 0x5F, 0xC3, 0xEB, 0x0A, 0x82, 0x09, 0xD1,
0xCA, 0x18, 0x47, 0xD9, 0x69, 0x5E, 0x8E, 0xE8,
0x95, 0xBA,
0x4A, 0xAA, 0xC2, 0xF5, 0x5F, 0xA5, 0x76, 0xB8,
0xDC, 0x42, 0xEE, 0xC2, 0x6D, 0xB8, 0x45, 0x67,
0x4E, 0x63, 0xBD, 0x90, 0x8D, 0x12, 0xF3, 0xBB,
0x0E, 0x0B, 0xED, 0x96, 0x4B, 0xC9, 0x13, 0x5B,
0xBD, 0x0C, 0xC9, 0xE4, 0x96, 0xD2, 0xC8, 0x76,
0x8F, 0x82, 0x6C,
0x21, 0x35, 0x8B, 0xF5, 0x7C, 0x72, 0xEB, 0xA3,
0x85, 0x75, 0x0B, 0xAA, 0x08, 0xBB, 0x50, 0xF8,
0xAC, 0x73, 0xA0, 0x28, 0x81, 0x6A, 0x04, 0x8D,
0x7B, 0x53, 0x71, 0x28, 0x66, 0xE4, 0xCE, 0xA3,
0x6B, 0x1B, 0x92, 0xD6, 0xF9, 0xC7, 0xD8, 0x11,
0x02, 0x6F, 0x1A, 0xEA,
0x9A, 0xD7, 0xCF, 0xEE, 0xDC, 0x49, 0xDC, 0xE8,
0x06, 0x1A, 0xD9, 0x23, 0xAD, 0x39, 0x94, 0x1A,
0x53, 0xFB, 0xB2, 0x2D, 0x7F, 0x96, 0x85, 0x11,
0xF0, 0x38, 0x73, 0x1F, 0xAD, 0xD1, 0x84, 0x5B,
0xB3, 0x84, 0x70, 0x3E, 0x33, 0x75, 0x35, 0x24,
0x08, 0x9A, 0x5D, 0x21, 0x9A,
0x38, 0x74, 0xF9, 0xEE, 0xE2, 0xD3, 0x30, 0xA4,
0xE4, 0x46, 0x7D, 0xC8, 0x10, 0x7F, 0xF1, 0xE3,
0x06, 0x16, 0x05, 0x70, 0x3B, 0x80, 0xED, 0xFE,
0xE6, 0x97, 0x78, 0x47, 0x19, 0x84, 0x2D, 0x17,
0x67, 0x04, 0x01, 0xC7, 0x24, 0xAD, 0x7E, 0x4A,
0xC4, 0x76, 0xC8, 0xB2, 0xC0, 0x2F,
0x13, 0x8B, 0xD7, 0x2A, 0xC9, 0x6A, 0x29, 0x7A,
0xE2, 0x78, 0xE8, 0xCF, 0x67, 0x9B, 0x37, 0x29,
0x6C, 0xF8, 0x3D, 0x37, 0x6F, 0x21, 0xE8, 0xC2,
0x64, 0xE1, 0xD4, 0x66, 0x7A, 0xE4, 0x72, 0x77,
0xAD, 0x0A, 0x24, 0xB8, 0x3C, 0x9B, 0x8E, 0xC1,
0x66, 0x94, 0xCC, 0x9E, 0x83, 0xBA, 0x53,
0xC7, 0xAB, 0x7B, 0x60, 0x42, 0x31, 0xB6, 0x90,
0xE1, 0xFA, 0x60, 0xE2, 0xFD, 0x62, 0xEF, 0xEA,
0xB7, 0x6F, 0x30, 0xE5, 0xB2, 0xCB, 0x49, 0x84,
0xD6, 0xFD, 0x3D, 0x38, 0x35, 0xB8, 0xB8, 0x95,
0x95, 0x63, 0xE9, 0xE7, 0x84, 0xCC, 0xFE, 0x71,
0x69, 0x51, 0xD1, 0x3F, 0x9D, 0x64, 0xB1, 0x5A,
0xFD, 0xD7, 0x30, 0x62, 0x23, 0xBD, 0xB1, 0xFB,
0x64, 0xFF, 0x4D, 0x59, 0x09, 0xA2, 0xBB, 0x2B,
0xE7, 0x4E, 0x37, 0x97, 0x66, 0x7C, 0x31, 0x36,
0xA7, 0xB6, 0x0B, 0x89, 0x70, 0xBB, 0xF6, 0xF5,
0xEB, 0x39, 0x82, 0x28, 0xD1, 0x99, 0x35, 0xEB,
0x62, 0x11, 0xE6, 0xFF, 0x33, 0xB0, 0x1F, 0x6B,
0x57,
0xE6, 0xB3, 0xDB, 0x95, 0x46, 0x70, 0x8F, 0x1B,
0x76, 0xFB, 0x39, 0xF2, 0xA9, 0xB5, 0x68, 0xD9,
0x2A, 0xF9, 0x91, 0x13, 0x2B, 0x45, 0x36, 0x9C,
0xF3, 0xBA, 0x5D, 0xF3, 0x2D, 0xD7, 0x20, 0xCE,
0x32, 0x8D, 0x18, 0xE9, 0x03, 0x0B, 0x8D, 0x1C,
0xD6, 0xC8, 0x75, 0x6B, 0x6C, 0x7C, 0xB3, 0xA1,
0x78, 0x7A,
0xE8, 0xDA, 0x83, 0xD9, 0x90, 0x9A, 0x3B, 0x5C,
0x44, 0x85, 0x27, 0xE6, 0x14, 0x7A, 0x0C, 0xF8,
0x21, 0x90, 0xA4, 0xDD, 0x3C, 0x23, 0x55, 0x6C,
0x33, 0xAF, 0xD7, 0x34, 0x1F, 0xA0, 0x4D, 0x47,
0x5D, 0x6D, 0x60, 0x1A, 0x84, 0x26, 0x48, 0x99,
0xC3, 0xD7, 0x35, 0x74, 0xC5, 0x32, 0xC1, 0x94,
0x7F, 0x12, 0x0A,
0xC6, 0x49, 0x15, 0xA3, 0x0A, 0xC8, 0x28, 0xF0,
0x7B, 0x34, 0x10, 0xD7, 0x88, 0x2A, 0x63, 0x56,
0xB0, 0xCC, 0x0E, 0xDF, 0xE4, 0x21, 0xDF, 0x7C,
0xD4, 0xB7, 0xA9, 0xAA, 0xF3, 0xE5, 0xC7, 0x11,
0x6F, 0xF4, 0x49, 0xFD, 0xE7, 0xCC, 0xD0, 0xC8,
0x23, 0xBE, 0xF5, 0xB7, 0x87, 0x31, 0x28, 0xF2,
0xC1, 0x73, 0xEE, 0x10,
0x4B, 0xF0, 0xF4, 0x7B, 0x8D, 0x67, 0x29, 0x3C,
0x15, 0x04, 0x4A, 0x2F, 0xB3, 0x94, 0x1E, 0x93,
0xB2, 0x86, 0xE2, 0x81, 0xB4, 0x36, 0xEE, 0x0D,
0x5C, 0x13, 0x55, 0x84, 0x70, 0x51, 0xA7, 0x07,
0x38, 0xD6, 0xAD, 0xD2, 0xC0, 0x12, 0x9C, 0x91,
0xF6, 0x71, 0xF6, 0xFF, 0x0D, 0x69, 0x75, 0x8C,
0x56, 0x39, 0x95, 0x45, 0x03,
0x11, 0x8D, 0x0E, 0xF0, 0xBC, 0xFF, 0xC4, 0x63,
0x4D, 0x02, 0x59, 0x06, 0x0B, 0xD3, 0xC8, 0x93,
0x4D, 0xA0, 0x59, 0x16, 0xC2, 0xBD, 0xD7, 0x49,
0xF1, 0x5F, 0xCB, 0x76, 0x90, 0x2B, 0x9C, 0x30,
0xC7, 0x66, 0x5F, 0x3F, 0x7E, 0x9F, 0x2C, 0xFD,
0xDD, 0x1D, 0xC7, 0xD5, 0xA2, 0xF5, 0xFB, 0x29,
0x31, 0x09, 0xB8, 0x22, 0x26, 0x11,
0x4F, 0x94, 0x55, 0x3D, 0xE7, 0xA2, 0xF2, 0x2D,
0x71, 0x0F, 0x7C, 0xA1, 0x50, 0x55, 0x56, 0x98,
0x80, 0xCD, 0xC6, 0x9A, 0xF2, 0x02, 0x67, 0x97,
0x22, 0xEA, 0x21, 0xF9, 0x28, 0xC7, 0x26, 0xA7,
0x9F, 0xE1, 0x2A, 0x12, 0x0B, 0x01, 0x19, 0xB0,
0x64, 0x1F, 0x67, 0xE0, 0x1D, 0x9C, 0x43, 0xF8,
0x2B, 0xDE, 0x17, 0xF7, 0x0C, 0xCB, 0x17,
0x4B, 0xFB, 0x26, 0x08, 0x29, 0x33, 0xAB, 0xA5,
0x25, 0xA9, 0x95, 0x2A, 0x58, 0x0B, 0x43, 0x40,
0xF2, 0xC7, 0x08, 0x79, 0x2F, 0x1A, 0xD0, 0x07,
0x7C, 0x72, 0x1B, 0x58, 0xEB, 0x18, 0x40, 0x20,
0x92, 0x5E, 0x03, 0x0C, 0x43, 0xFA, 0x8A, 0xFD,
0x02, 0x2B, 0xE9, 0xFE, 0x74, 0x6A, 0x14, 0xF4,
0x05, 0x49, 0xF1, 0x7E, 0x30, 0x5F, 0x49, 0xC0,
0x62, 0xB4, 0xD9, 0x9B, 0x34, 0x10, 0xE6, 0x0A,
0xF6, 0xF9, 0xF1, 0x96, 0x33, 0x26, 0x8E, 0x60,
0x34, 0x89, 0xD8, 0xB8, 0x8B, 0xBE, 0x1F, 0x9B,
0x6C, 0x1A, 0xDA, 0xA4, 0x52, 0x42, 0xA2, 0x28,
0x0D, 0x03, 0xA1, 0x73, 0x0F, 0x4E, 0x57, 0xB9,
0x0C, 0xC7, 0x41, 0x36, 0x99, 0x60, 0xA6, 0x2B,
0xE9, 0xE2, 0x2F, 0x77, 0xAF, 0x26, 0x3C, 0xC9,
0x37,
0x80, 0xB6, 0x35, 0x94, 0xB1, 0x74, 0x62, 0xDD,
0x35, 0xC1, 0x54, 0x63, 0x87, 0xEA, 0x8B, 0xD6,
0x1E, 0xC9, 0xE0, 0xE9, 0x16, 0x60, 0xFE, 0x7B,
0x7E, 0xE3, 0xBE, 0x3C, 0xBA, 0xA8, 0x86, 0xB8,
0x90, 0x34, 0xB2, 0x3E, 0x79, 0x0A, 0x6A, 0x53,
0x8B, 0x06, 0xE2, 0xB9, 0x25, 0x15, 0x90, 0xE8,
0x7D, 0x47, 0x4A, 0x89, 0x35, 0x19, 0x64, 0xAA,
0x6A, 0x25,
0x9C, 0xC1, 0xE5, 0x09, 0x81, 0x05, 0x04, 0x41,
0xB8, 0x96, 0x9C, 0x4E, 0x0B, 0xED, 0xFC, 0xC8,
0x4B, 0xEF, 0x96, 0xEF, 0x58, 0xD6, 0x3B, 0x56,
0x37, 0xE4, 0xA2, 0x93, 0xB2, 0xA9, 0x06, 0x41,
0xF0, 0x80, 0x13, 0xAA, 0x4E, 0x6B, 0xDA, 0xB9,
0x95, 0xFA, 0x55, 0xDD, 0x7A, 0x9F, 0xC9, 0x87,
0x48, 0xC6, 0x09, 0xB2, 0x4A, 0xE0, 0x71, 0x6C,
0x5E, 0x3C, 0x9E,
0x03, 0xD9, 0x40, 0x07, 0xE3, 0x5B, 0x56, 0xAD,
0x87, 0x74, 0x31, 0xE6, 0xB4, 0x03, 0xD4, 0x48,
0x98, 0x3F, 0xB0, 0x56, 0xC6, 0xCC, 0x22, 0xAF,
0xCA, 0x6C, 0xC6, 0x52, 0x23, 0x32, 0x67, 0x9C,
0x06, 0xC6, 0x14, 0xCD, 0x8E, 0xB4, 0x6E, 0xF0,
0x76, 0x2B, 0x7D, 0x99, 0xE3, 0x96, 0x4B, 0xB6,
0x42, 0x60, 0xE3, 0x58, 0x27, 0x63, 0x9C, 0x32,
0x5A, 0xD7, 0xB4, 0x53,
0x77, 0x42, 0x89, 0xA2, 0xF2, 0xB8, 0x74, 0x66,
0x20, 0xE1, 0x21, 0x14, 0x57, 0xE5, 0xE1, 0x3F,
0x36, 0xC4, 0xDA, 0xB7, 0xAA, 0xF0, 0x9E, 0xB9,
0x69, 0x0C, 0x35, 0x6C, 0x18, 0x5F, 0x31, 0x81,
0x35, 0x13, 0x37, 0x5A, 0x50, 0xDA, 0xC4, 0xE5,
0x60, 0x07, 0xC6, 0xA6, 0x5C, 0xE7, 0xFF, 0x4E,
0xD9, 0x00, 0x1D, 0x20, 0xFE, 0x94, 0x35, 0x23,
0x20, 0xE8, 0x80, 0x58, 0x06,
0x50, 0xB5, 0x6E, 0xA2, 0x93, 0xBD, 0xCC, 0xA9,
0xAD, 0x4C, 0x7E, 0xD7, 0xBE, 0x26, 0xAD, 0x4D,
0x2E, 0x25, 0x1A, 0x09, 0xA8, 0x9C, 0x48, 0x6A,
0xEF, 0x11, 0x76, 0xEC, 0xE9, 0xB2, 0x04, 0x28,
0x89, 0x80, 0xF9, 0x1A, 0x60, 0xA1, 0x9D, 0xE1,
0x1A, 0x4C, 0x83, 0xAA, 0x7C, 0x63, 0x69, 0xD9,
0x02, 0x9D, 0x14, 0xF7, 0xF7, 0x0C, 0x26, 0x07,
0x16, 0x9B, 0x4A, 0x25, 0x4F, 0xF4,
0xCE, 0xBD, 0x1A, 0x2F, 0xCB, 0xF5, 0x8D, 0x8C,
0x1C, 0xA2, 0x4F, 0xD8, 0xD5, 0xB9, 0x04, 0x6E,
0x77, 0x0E, 0x49, 0xDA, 0x8D, 0x13, 0xD4, 0x49,
0x55, 0x12, 0x87, 0x30, 0x2D, 0xFB, 0xF8, 0x02,
0xE9, 0xD1, 0x54, 0x69, 0x5D, 0xB5, 0x00, 0x49,
0xA4, 0xC0, 0x8B, 0xD2, 0x92, 0x54, 0xC0, 0x05,
0xCA, 0xDD, 0xF1, 0x5B, 0x11, 0xEC, 0x59, 0xD7,
0x99, 0x08, 0x10, 0x2D, 0x06, 0xAD, 0xCA,
0xD9, 0x04, 0xA6, 0x9F, 0x1E, 0xE5, 0x5C, 0x5F,
0xC6, 0x1B, 0xA1, 0x1F, 0xA9, 0x63, 0x1F, 0x0A,
0xC1, 0x60, 0x0D, 0x81, 0x35, 0x97, 0x08, 0x23,
0x40, 0x1A, 0x41, 0xFC, 0x58, 0x51, 0x04, 0x97,
0xBD, 0xC3, 0xC3, 0x32, 0x5D, 0x28, 0xAF, 0xE7,
0xB5, 0xA4, 0x29, 0x61, 0x0C, 0xD8, 0xF2, 0xD6,
0x4F, 0xC2, 0x6F, 0x5B, 0xA1, 0x64, 0xFB, 0x55,
0x49, 0x27, 0x08, 0x17, 0x7D, 0x2B, 0x68, 0xD1,
0xBC, 0x89, 0x75, 0x83, 0x82, 0x6D, 0x98, 0x11,
0x4E, 0x04, 0x84, 0xC0, 0xCD, 0x93, 0x73, 0x29,
0x0E, 0x70, 0x9B, 0x62, 0xE0, 0x97, 0x63, 0x27,
0x70, 0x1E, 0x08, 0xE5, 0xF0, 0x88, 0xAF, 0xBC,
0xAC, 0x39, 0xC8, 0x93, 0x9D, 0x32, 0xF0, 0x03,
0xEA, 0x33, 0x25, 0xA5, 0xDA, 0xD5, 0xC4, 0x94,
0xF5, 0xB4, 0xC8, 0xF8, 0x2B, 0xDE, 0x13, 0x59,
0x8C, 0x04, 0x8C, 0xBC, 0x3A, 0xD8, 0x63, 0xCB,
0xAF,
0xCB, 0x95, 0xC1, 0xE9, 0x80, 0x91, 0xE9, 0xE7,
0xE6, 0x6B, 0x98, 0x55, 0xD2, 0x3B, 0x37, 0x27,
0x13, 0x37, 0x41, 0x2E, 0x2D, 0x49, 0xE6, 0x83,
0x37, 0x9D, 0x24, 0x37, 0x55, 0xB4, 0xEE, 0x29,
0xFC, 0x9E, 0x55, 0xA3, 0x94, 0xF3, 0x6C, 0x93,
0x7E, 0x90, 0x18, 0x1B, 0x0C, 0x0C, 0x22, 0x44,
0xB0, 0xB2, 0x3D, 0xC9, 0xAF, 0x47, 0x63, 0x56,
0x6D, 0x2D, 0xB4, 0xCA, 0x03, 0xF3, 0x99, 0xB8,
0x61, 0xD9,
0x4B, 0x94, 0xC4, 0x59, 0x93, 0x95, 0xD8, 0xB2,
0xCE, 0x8A, 0x89, 0x7F, 0x72, 0x07, 0x22, 0xC3,
0x69, 0x49, 0x86, 0xAB, 0xFC, 0xEC, 0x95, 0xDB,
0x7B, 0x59, 0x58, 0x13, 0x5C, 0xE9, 0x46, 0x41,
0x08, 0x08, 0x47, 0x76, 0xA9, 0xBB, 0x37, 0xA6,
0x88, 0xB3, 0x1D, 0x23, 0x2D, 0x23, 0x1E, 0x91,
0xDD, 0x6B, 0x6D, 0x9C, 0xEF, 0x0F, 0xCF, 0xB6,
0xBC, 0x02, 0x19, 0xED, 0x20, 0xFC, 0x86, 0xF7,
0x41, 0x6A, 0x3C,
0xBD, 0xEE, 0xA8, 0xFE, 0x8D, 0xE3, 0xB2, 0xB6,
0x92, 0xB4, 0xB7, 0x00, 0x5B, 0x59, 0x52, 0x53,
0x64, 0x7A, 0x7D, 0x2C, 0xE9, 0x73, 0x08, 0x09,
0xF8, 0x5C, 0x6B, 0xA0, 0xCD, 0xFE, 0x21, 0x9E,
0xE9, 0x05, 0x2D, 0x2C, 0x3A, 0x1D, 0xA2, 0xA9,
0x07, 0x50, 0x73, 0xCD, 0xD6, 0xE9, 0x8D, 0x64,
0xB4, 0x50, 0x85, 0x35, 0xAC, 0x88, 0x4A, 0x22,
0x6F, 0x5E, 0x24, 0xC9, 0xD3, 0x2B, 0xFB, 0x28,
0x5E, 0x97, 0x2A, 0x16,
0xAB, 0x5A, 0x77, 0x2F, 0xE5, 0x8F, 0x10, 0xB4,
0x66, 0xBB, 0x93, 0xE2, 0x82, 0x97, 0x7E, 0x2B,
0x8B, 0x5F, 0x7A, 0x0E, 0xC1, 0xA6, 0xA3, 0xE6,
0x2D, 0xA1, 0x12, 0xCB, 0x3D, 0x50, 0x89, 0x1A,
0xE2, 0x98, 0xF0, 0x84, 0xA8, 0x80, 0x85, 0xBB,
0x9D, 0x55, 0x48, 0x4D, 0xDC, 0x25, 0x94, 0x92,
0xB2, 0x5A, 0x3D, 0xB5, 0x9D, 0xC1, 0xB0, 0x50,
0x60, 0x09, 0x69, 0xB3, 0x38, 0xC9, 0x10, 0x50,
0x89, 0x4D, 0x86, 0x55, 0x7E,
0x51, 0x23, 0xF1, 0xFC, 0x7B, 0xC1, 0xED, 0x55,
0xD7, 0x56, 0x06, 0xCD, 0x0D, 0xD3, 0xCE, 0xE1,
0xA9, 0xD7, 0xC6, 0x93, 0xD3, 0x96, 0x5F, 0x2B,
0x6A, 0x67, 0xC1, 0xE2, 0xFC, 0xE5, 0x03, 0xAA,
0x5F, 0x81, 0x48, 0xD9, 0x18, 0xAC, 0x45, 0xC8,
0xD8, 0x90, 0xE4, 0xC2, 0x20, 0x3E, 0x55, 0xC7,
0xB8, 0x03, 0x83, 0x57, 0x8A, 0xF3, 0xA7, 0x64,
0x0A, 0xA0, 0xAE, 0x2B, 0x39, 0x59, 0x56, 0x59,
0x96, 0x48, 0x67, 0x44, 0xF8, 0xD6,
0x8E, 0xBE, 0xA6, 0xC8, 0x60, 0x67, 0xBB, 0xF3,
0xEB, 0x02, 0x2F, 0xEF, 0x78, 0x4C, 0x5E, 0xE9,
0xE9, 0x4B, 0xF5, 0x2E, 0x00, 0x7E, 0xBC, 0x88,
0x97, 0x60, 0x76, 0xCA, 0xF3, 0xC9, 0x82, 0x5E,
0x6B, 0x67, 0x42, 0x08, 0x36, 0xF6, 0x86, 0x05,
0xB9, 0x1F, 0xED, 0x47, 0x17, 0x9E, 0x12, 0x17,
0xF7, 0xA4, 0x27, 0x00, 0x0D, 0xBB, 0x0C, 0x77,
0xD8, 0x9D, 0xE4, 0xD1, 0xB2, 0x74, 0xEF, 0x6C,
0x69, 0x4A, 0x31, 0x71, 0x6F, 0x41, 0x72,
0x08, 0x20, 0xFB, 0xD7, 0xE8, 0x55, 0xED, 0x96,
0xEC, 0x11, 0x3B, 0xA4, 0x52, 0x36, 0x06, 0xDC,
0x44, 0x58, 0x8D, 0x7C, 0x81, 0xD2, 0xB8, 0x56,
0xE0, 0x85, 0x84, 0xE3, 0x17, 0x37, 0x75, 0x61,
0xDE, 0xE3, 0x1A, 0x61, 0xAE, 0xBB, 0x32, 0x02,
0xE3, 0xC6, 0x29, 0xFF, 0x75, 0xCD, 0xAD, 0x48,
0x4F, 0x9D, 0xBF, 0x77, 0x6B, 0x6E, 0x6D, 0x9C,
0x0B, 0x3F, 0x9B, 0x99, 0x24, 0x67, 0x07, 0xED,
0xDC, 0x00, 0x74, 0x35, 0xF1, 0x75, 0x8C, 0x39,
0x1F, 0x15, 0xD2, 0x4F, 0x1D, 0x0B, 0x2B, 0x3F,
0x8A, 0x9C, 0x43, 0xB9, 0x0C, 0xDF, 0xCD, 0xE2,
0x74, 0xDA, 0x3B, 0xA8, 0x5C, 0xB0, 0x6C, 0x96,
0xA7, 0xEF, 0x2D, 0x60, 0xFF, 0x5C, 0x47, 0x7F,
0x0A, 0x41, 0x8B, 0xBF, 0x71, 0x21, 0x48, 0x9F,
0x30, 0x03, 0x75, 0xEC, 0x5B, 0xE2, 0x6A, 0x61,
0xD5, 0x80, 0x12, 0x0B, 0x76, 0xDC, 0x76, 0x40,
0xD1, 0x43, 0xC9, 0xBD, 0xFC, 0xB2, 0xB8, 0x07,
0x80, 0x4E, 0x8F, 0xD1, 0xFC, 0xCF, 0xB5, 0x05,
0xC7,
0x34, 0x55, 0x64, 0x75, 0xB5, 0xF2, 0xEF, 0xF3,
0xEE, 0xCA, 0x43, 0x1C, 0xE3, 0xC7, 0x50, 0x27,
0x6A, 0xFA, 0x63, 0xDA, 0x99, 0x36, 0x6E, 0x42,
0x8A, 0x7A, 0xCF, 0x7C, 0xBE, 0x21, 0x83, 0x35,
0x20, 0x9F, 0x26, 0xAB, 0x52, 0x2D, 0xA7, 0x80,
0x92, 0xDA, 0x8B, 0xF6, 0x72, 0xF6, 0xA0, 0xB7,
0x78, 0xC0, 0xB2, 0x07, 0x0A, 0x6E, 0x78, 0x90,
0xD0, 0x55, 0x23, 0xB4, 0xD6, 0x0F, 0x0C, 0xBF,
0x5A, 0xDF, 0x4D, 0xA2, 0xA5, 0xC6, 0xA0, 0x53,
0x31, 0x7E,
0x0B, 0x8E, 0x7F, 0x62, 0x1D, 0xF8, 0x6D, 0x2C,
0xED, 0xBE, 0xF8, 0xE2, 0x04, 0x08, 0x15, 0x47,
0xB1, 0x05, 0xF8, 0x16, 0x40, 0xC3, 0x31, 0x33,
0x44, 0xEE, 0x20, 0x41, 0x26, 0x4E, 0x19, 0x0E,
0x0E, 0xEF, 0x77, 0x56, 0x5A, 0x28, 0x7F, 0xCD,
0x40, 0x5F, 0x8F, 0x24, 0x3A, 0x54, 0xC3, 0x67,
0x23, 0x07, 0x32, 0xC5, 0x5D, 0x71, 0x1B, 0x39,
0x8F, 0xCF, 0xC0, 0xD8, 0x3E, 0xBF, 0x8A, 0x72,
0xF2, 0x5B, 0x9C, 0x89, 0x36, 0x4D, 0xD9, 0xF5,
0x6C, 0xCA, 0x0E,
0x8C, 0x0E, 0x35, 0x4F, 0x79, 0x3F, 0x9A, 0xCD,
0x2B, 0xF2, 0x60, 0xC7, 0xE9, 0x4C, 0x9C, 0x7D,
0x28, 0xAB, 0x1A, 0xC5, 0x80, 0x02, 0x27, 0x1D,
0xD5, 0xD3, 0x2D, 0x78, 0x15, 0xE6, 0xB9, 0x77,
0x24, 0xE1, 0x68, 0x23, 0xB5, 0xA5, 0x45, 0x28,
0x0E, 0xFA, 0x7C, 0x05, 0x52, 0x47, 0x4C, 0xA4,
0x4D, 0x7C, 0x03, 0xC5, 0x03, 0x01, 0x6D, 0x7A,
0xC5, 0x95, 0xF5, 0x39, 0xE5, 0x3D, 0x28, 0x39,
0xA2, 0x2D, 0x31, 0x04, 0xBC, 0x8D, 0x2A, 0xC9,
0xF2, 0xA1, 0xED, 0x46,
0xCB, 0xE7, 0x62, 0xA5, 0x47, 0xCA, 0x96, 0x9E,
0x6F, 0x00, 0xA9, 0xF0, 0x18, 0x31, 0xAB, 0x10,
0xFF, 0x44, 0x6C, 0xD2, 0x00, 0xB9, 0x5A, 0x64,
0x1C, 0x23, 0xD5, 0xA0, 0x0D, 0x55, 0x37, 0xBC,
0xA9, 0xC8, 0x22, 0x0F, 0xE7, 0x35, 0x63, 0x5E,
0xDC, 0x2C, 0x3F, 0xC2, 0x0E, 0xBA, 0x0B, 0xCB,
0x1E, 0xDA, 0x4A, 0xBA, 0xB6, 0x2C, 0x85, 0x61,
0x53, 0x79, 0x88, 0x8C, 0xD6, 0xB0, 0xD5, 0x59,
0xD0, 0x7F, 0x5C, 0xB7, 0x49, 0xE0, 0xED, 0x9D,
0x1D, 0x91, 0xA6, 0x0D, 0xEF,
0xF3, 0x09, 0x05, 0x82, 0xBE, 0x90, 0x84, 0x30,
0xD7, 0x0A, 0x37, 0xDD, 0xC8, 0x70, 0x0C, 0xFE,
0x77, 0xDB, 0xE5, 0x16, 0x89, 0xC1, 0x94, 0x45,
0x0D, 0x89, 0xA2, 0xC5, 0x45, 0x83, 0x62, 0x49,
0x23, 0xF8, 0xE2, 0xE6, 0x52, 0xC6, 0x84, 0x27,
0x31, 0x43, 0x46, 0x72, 0x44, 0xCA, 0x65, 0x6C,
0x44, 0x8C, 0x10, 0x66, 0xE3, 0x0F, 0x1F, 0xD9,
0x4B, 0xB9, 0xC6, 0xAE, 0x11, 0x26, 0xD5, 0x33,
0x42, 0x14, 0xE0, 0x2A, 0x46, 0x9B, 0x1A, 0x05,
0x6F, 0x55, 0x80, 0x74, 0xEF, 0xEE,
0xD3, 0xF6, 0xC0, 0x37, 0xAD, 0xC9, 0x87, 0x7C,
0x8A, 0xC4, 0x60, 0x3B, 0xC1, 0x63, 0xC8, 0xFC,
0xC4, 0xBF, 0x89, 0xAB, 0xB7, 0x8A, 0x1F, 0xA1,
0xC9, 0x81, 0x71, 0xDE, 0xD5, 0x15, 0xB4, 0x18,
0xAE, 0x7F, 0xFB, 0x5B, 0x51, 0x2C, 0x47, 0x80,
0x25, 0xD0, 0x1D, 0xB5, 0x1E, 0xFF, 0xEB, 0x3C,
0x8A, 0xE5, 0x89, 0x1C, 0x0B, 0x54, 0x89, 0x6A,
0xC4, 0x98, 0xAD, 0x27, 0x10, 0x58, 0x91, 0xC7,
0xFB, 0xD5, 0xB9, 0x53, 0xC3, 0xAD, 0x40, 0xFE,
0xBA, 0xC9, 0x6E, 0x03, 0x70, 0xEF, 0x2E,
0xA0, 0x63, 0x21, 0xD3, 0xA9, 0x7D, 0x0C, 0xB5,
0x7A, 0x74, 0x87, 0x47, 0x9E, 0xAC, 0xC7, 0x43,
0x8F, 0x2D, 0x0B, 0xF2, 0xA5, 0x6A, 0x31, 0xD7,
0x80, 0xA7, 0xCE, 0xDF, 0xB8, 0x45, 0x1F, 0x5D,
0xCF, 0x07, 0x8D, 0x78, 0x71, 0xFA, 0x57, 0x10,
0x6E, 0xC9, 0x01, 0x86, 0xFA, 0xA2, 0x3C, 0xE6,
0x44, 0x87, 0x57, 0x53, 0x56, 0x05, 0x36, 0x33,
0x78, 0x01, 0x73, 0x60, 0x9F, 0xF0, 0xDA, 0x90,
0x0E, 0x5F, 0x61, 0x24, 0x16, 0x52, 0x80, 0xED,
0xB5, 0x85, 0x5F, 0x1D, 0x2F, 0xC4, 0xCB, 0x2A,
0x5F, 0x2F, 0x4F, 0xF7, 0x9D, 0xFB, 0x17, 0x87,
0x8E, 0xCB, 0x5C, 0xB9, 0x63, 0x2E, 0x10, 0xF9,
0x19, 0x60, 0x90, 0xDA, 0x4C, 0x28, 0xE8, 0x34,
0x0F, 0xE1, 0x5D, 0x72, 0x5B, 0x18, 0x23, 0x9C,
0xEF, 0x17, 0xF7, 0x4A, 0xD1, 0xE1, 0x26, 0x26,
0x1C, 0xE8, 0x0B, 0xB2, 0x4A, 0x86, 0xB1, 0x05,
0x75, 0x5F, 0x56, 0x12, 0x9E, 0x60, 0xE6, 0x50,
0xC2, 0x25, 0x43, 0x71, 0x25, 0xB7, 0xA6, 0xFC,
0x60, 0x24, 0x74, 0x01, 0x2C, 0x45, 0xA5, 0xF0,
0x45, 0x66, 0x4A, 0x17, 0x01, 0xE6, 0xC5, 0x7A,
0xE4,
0xD4, 0x1F, 0x5F, 0xC2, 0xA9, 0x2C, 0x9F, 0x77,
0x4E, 0xBC, 0x25, 0xA1, 0xC8, 0xF4, 0xF8, 0x7A,
0x74, 0xFE, 0x47, 0xDF, 0xE7, 0xA7, 0x08, 0x26,
0xC2, 0xE5, 0xB6, 0xAB, 0xD6, 0x52, 0x32, 0x97,
0x7F, 0xD7, 0xCE, 0xAA, 0xEF, 0xB2, 0x6A, 0xAB,
0xAC, 0xA9, 0xC7, 0xDD, 0x2A, 0x9D, 0xE4, 0x12,
0x40, 0x7E, 0xF4, 0xB5, 0xFF, 0x39, 0x00, 0x31,
0x0C, 0x1F, 0x24, 0xEC, 0x1A, 0xDF, 0xBE, 0x40,
0xE0, 0x51, 0x70, 0xCF, 0xDC, 0xB7, 0x4F, 0x3D,
0x0A, 0x52, 0x99, 0x76, 0x31, 0xED, 0x24, 0x09,
0x47, 0xB9,
0x7F, 0x78, 0x93, 0x1B, 0x69, 0xB9, 0xE9, 0x44,
0x69, 0xD9, 0xDB, 0xE6, 0xFD, 0x15, 0x8B, 0x82,
0xCD, 0x32, 0x91, 0x8B, 0x60, 0x98, 0x57, 0x3E,
0xB0, 0xF9, 0x3A, 0x86, 0x8F, 0xEF, 0xDA, 0xAA,
0x91, 0x2B, 0x38, 0xF3, 0x7C, 0xBF, 0xB7, 0x5E,
0x4C, 0xD0, 0xA0, 0x4D, 0x87, 0xEB, 0x3E, 0xD6,
0x0C, 0xD1, 0xA7, 0x9B, 0xDE, 0x43, 0xE0, 0x63,
0x70, 0x17, 0x1E, 0x07, 0x87, 0x0E, 0xDD, 0x37,
0x37, 0x38, 0x76, 0x99, 0x53, 0x1C, 0x9C, 0x7A,
0x37, 0x2B, 0x6C, 0xF1, 0xA5, 0x00, 0x73, 0x73,
0x74, 0x98, 0xD8,
0x45, 0x02, 0x7D, 0x54, 0xAC, 0x3C, 0x51, 0xC2,
0x9A, 0xC0, 0x1A, 0x65, 0xBE, 0x7F, 0x80, 0x57,
0x34, 0x9D, 0xDA, 0xC7, 0x8E, 0x95, 0x93, 0x31,
0xE5, 0xBE, 0xF4, 0x49, 0x56, 0x10, 0x8C, 0x66,
0x66, 0x9A, 0x16, 0x12, 0x06, 0x52, 0x4B, 0xD5,
0xE9, 0xEB, 0xBD, 0xFF, 0x91, 0xB7, 0xC2, 0x93,
0x71, 0xB9, 0x9A, 0xB2, 0xF9, 0xF7, 0xD0, 0xC4,
0x58, 0xA3, 0x89, 0x54, 0xCE, 0xA0, 0x31, 0x06,
0x71, 0x60, 0xBC, 0x11, 0xFC, 0xB2, 0xE0, 0x20,
0x8F, 0x73, 0xA1, 0x0D, 0xD6, 0x0A, 0x66, 0x80,
0x7D, 0xEF, 0x4D, 0x04,
0xB0, 0x38, 0x3D, 0xF5, 0x2F, 0xD8, 0x49, 0x84,
0x2E, 0x81, 0x44, 0xB8, 0x3F, 0x2A, 0x56, 0xD4,
0xC1, 0x5B, 0xF0, 0x80, 0x22, 0xC9, 0x4F, 0x13,
0x95, 0xA6, 0xFB, 0x1C, 0xBD, 0x82, 0xC9, 0x67,
0x37, 0x25, 0x21, 0x26, 0xA1, 0x4D, 0x71, 0xA7,
0xCC, 0x35, 0xB4, 0xF8, 0x9E, 0x92, 0xCB, 0x38,
0xBC, 0xAA, 0x9D, 0x5D, 0xFB, 0x04, 0x0B, 0xD7,
0xE2, 0x40, 0x0B, 0x84, 0x97, 0x22, 0x6A, 0x67,
0xA9, 0x6A, 0xB8, 0x43, 0x76, 0xA8, 0x66, 0xCC,
0x58, 0xB3, 0x3F, 0x98, 0x2A, 0xC5, 0x02, 0x77,
0x4B, 0xC7, 0x81, 0xFA, 0x9E,
0x3B, 0xFD, 0xCA, 0x9F, 0x2D, 0xE0, 0x46, 0x6D,
0x0A, 0x25, 0xDD, 0x6D, 0x26, 0x5A, 0x2F, 0x33,
0xEC, 0x4F, 0xCC, 0x13, 0xC5, 0x1B, 0x66, 0xF4,
0xC4, 0x9A, 0x16, 0xCC, 0x98, 0x2D, 0x34, 0x34,
0x40, 0xDD, 0x51, 0x22, 0xDB, 0xF6, 0x2A, 0xA7,
0x30, 0xD5, 0x63, 0xC0, 0x8F, 0x90, 0x57, 0xFC,
0x09, 0xBE, 0x22, 0xB1, 0x29, 0xC5, 0xDC, 0x81,
0x03, 0x99, 0x35, 0x7D, 0x1E, 0x85, 0xC2, 0xA0,
0x29, 0x55, 0xEA, 0xEB, 0xD7, 0x8C, 0xF4, 0x46,
0xA7, 0x6D, 0x29, 0x8A, 0x6B, 0x38, 0x00, 0x3C,
0x38, 0x52, 0x7B, 0x44, 0x28, 0x5E,
0xD5, 0x24, 0x00, 0xA6, 0xA7, 0x82, 0x5C, 0x52,
0xAB, 0x2A, 0xCE, 0xCB, 0xD5, 0x53, 0x3F, 0x12,
0x92, 0xB8, 0x32, 0x87, 0x16, 0xB5, 0xCA, 0x10,
0x75, 0xB5, 0x69, 0x86, 0x3D, 0xB1, 0x8D, 0x23,
0x29, 0x96, 0x7C, 0xB4, 0x7F, 0xE7, 0xC2, 0x59,
0xE8, 0x28, 0x9A, 0x38, 0x46, 0xB7, 0xE8, 0x7C,
0x48, 0xFA, 0x73, 0xD4, 0xD7, 0x98, 0xED, 0x1D,
0x58, 0xEC, 0xB6, 0xAA, 0x61, 0xC4, 0x68, 0xF9,
0xF7, 0xF6, 0xFD, 0x9F, 0xB8, 0x36, 0xA6, 0x10,
0x52, 0x0C, 0x6C, 0x8F, 0x6A, 0x66, 0xD8, 0x5C,
0x0E, 0x66, 0xF2, 0x6E, 0xBE, 0x65, 0x23,
0xDC, 0xA5, 0x73, 0x95, 0xA7, 0x94, 0xD7, 0x74,
0xD7, 0xE7, 0x7B, 0xBE, 0x30, 0x4E, 0xD5, 0x13,
0xF3, 0x64, 0x59, 0x73, 0xDC, 0x5C, 0xCD, 0x64,
0x99, 0xA7, 0xB5, 0x57, 0xCE, 0x11, 0x62, 0x3A,
0x41, 0xC1, 0xA1, 0x2C, 0x67, 0xFB, 0x7E, 0x71,
0xC7, 0xE6, 0x42, 0x3A, 0x70, 0x23, 0xD8, 0xA4,
0x65, 0x4F, 0x63, 0x92, 0xE1, 0x83, 0xF1, 0x38,
0x22, 0x82, 0x5C, 0xD2, 0xAB, 0xF7, 0x2A, 0x1E,
0x1D, 0xA9, 0xAB, 0xEE, 0xB5, 0x3D, 0xED, 0xDA,
0xF8, 0xD3, 0xBF, 0xFF, 0x51, 0xA1, 0x4A, 0x92,
0x96, 0x96, 0x5B, 0xCD, 0x2A, 0xAF, 0x0F, 0xF6,
0xF7, 0x6C, 0x9C, 0x10, 0x4F, 0x29, 0x68, 0x4E,
0x5B, 0x06, 0x71, 0xB4, 0x89, 0x40, 0xAD, 0x1C,
0x80, 0x18, 0x8F, 0xB5, 0xFE, 0xB5, 0x97, 0xF8,
0xE8, 0xDE, 0x12, 0x4C, 0x3C, 0x5E, 0x3F, 0xCC,
0xDC, 0xDD, 0x7B, 0xAD, 0x72, 0x61, 0x97, 0x9E,
0x62, 0xC4, 0xA4, 0x94, 0x07, 0x80, 0x3E, 0x22,
0x4E, 0x2E, 0xA9, 0x23, 0x36, 0xAE, 0x72, 0xA7,
0xE1, 0x29, 0x78, 0x98, 0x77, 0x37, 0x7B, 0xAE,
0x6E, 0xEF, 0x94, 0xCB, 0x99, 0x4E, 0x82, 0xE9,
0x28, 0x9B, 0xD0, 0xFA, 0x02, 0x9A, 0x7E, 0xB2,
0xBB, 0xBC, 0x70, 0xCF, 0x48, 0x76, 0x46, 0x75,
0xD2,
0xE2, 0x8D, 0x7E, 0xC1, 0x6A, 0x9C, 0x50, 0x8A,
0x8B, 0x7E, 0xBB, 0xE5, 0x41, 0x68, 0x2E, 0x55,
0xFC, 0x9F, 0xC7, 0xE2, 0x37, 0x6C, 0x3F, 0xEB,
0xA4, 0xD7, 0xD5, 0x08, 0x6A, 0x52, 0x6E, 0xE7,
0x83, 0x58, 0x11, 0x5C, 0x29, 0xA4, 0x29, 0x6C,
0xD2, 0xA7, 0xDD, 0x54, 0x3E, 0xEC, 0xD1, 0x7B,
0x84, 0xDD, 0xFD, 0x36, 0x12, 0x62, 0x74, 0x9F,
0x5C, 0xC8, 0xEA, 0x89, 0x4B, 0xFA, 0xC0, 0xCE,
0x1F, 0x8C, 0x33, 0x48, 0x98, 0xA0, 0xBB, 0x6E,
0x1E, 0xBD, 0xE7, 0xD7, 0xB3, 0x35, 0xC1, 0x28,
0x50, 0x5B, 0xFD, 0x06, 0x01, 0x56, 0xE4, 0xD8,
0x85, 0x13,
0x07, 0x47, 0x46, 0x65, 0xD1, 0x22, 0x89, 0x95,
0xB3, 0xF6, 0x20, 0xF0, 0x7E, 0x8A, 0x53, 0xE9,
0x68, 0x01, 0xEE, 0x60, 0xED, 0x14, 0x81, 0xA1,
0x45, 0x50, 0x57, 0x9B, 0x5F, 0xF9, 0xBE, 0xFE,
0x62, 0x49, 0x2F, 0xC3, 0x8B, 0x1A, 0x2B, 0xC6,
0x31, 0x9E, 0x0F, 0x0F, 0xEA, 0x36, 0xCE, 0x30,
0xA7, 0xD9, 0xE6, 0xD9, 0x6B, 0xE2, 0x5B, 0x46,
0x21, 0x1A, 0x7D, 0x31, 0x2D, 0xE1, 0xCA, 0xF7,
0xD9, 0xB7, 0xD0, 0x3C, 0xC6, 0x97, 0x59, 0xCC,
0xB0, 0xD0, 0xE1, 0x3A, 0x8A, 0x4B, 0x8A, 0x89,
0xC6, 0x9F, 0x14, 0x26, 0x51, 0x94, 0x6A, 0x08,
0x19, 0xE2, 0x63,
0xA7, 0x15, 0x38, 0x35, 0x0B, 0x71, 0xDC, 0x55,
0x2A, 0xAB, 0x54, 0x74, 0x38, 0x1B, 0x9A, 0x58,
0xA4, 0x0F, 0x77, 0x36, 0x28, 0x6D, 0x45, 0x76,
0xED, 0x09, 0xEA, 0xFC, 0x33, 0x01, 0x3B, 0x25,
0xA2, 0x8C, 0x8D, 0xD9, 0x03, 0x26, 0xD1, 0x78,
0x8F, 0x55, 0xF5, 0x6D, 0x29, 0xA5, 0x08, 0x4F,
0xE8, 0x6A, 0x47, 0x2F, 0x5F, 0x4D, 0xA9, 0x36,
0x2E, 0xE4, 0x07, 0x97, 0xE4, 0x9D, 0xCC, 0x94,
0x63, 0xBF, 0x8A, 0xD4, 0xEF, 0xD4, 0x59, 0x71,
0xDC, 0xFE, 0xF1, 0xEF, 0xE4, 0x95, 0x04, 0x56,
0xD8, 0xD9, 0x58, 0x97, 0x8E, 0x36, 0x41, 0x79,
0x0E, 0x5A, 0xC5, 0x7D,
0xDC, 0x2A, 0xCE, 0x12, 0x74, 0x49, 0x4C, 0xB1,
0x31, 0x95, 0x83, 0x52, 0x40, 0xD7, 0x89, 0xF8,
0xCB, 0x45, 0xCC, 0xCC, 0x9C, 0xAE, 0xE8, 0x1F,
0x06, 0xEA, 0x2A, 0x66, 0x83, 0x6E, 0x50, 0xC1,
0xC9, 0xFC, 0x48, 0x46, 0xC0, 0x24, 0xFB, 0x03,
0xB7, 0x31, 0xC4, 0x68, 0x6A, 0x59, 0x0D, 0xCE,
0x35, 0x03, 0x09, 0x7B, 0x5B, 0x61, 0xEA, 0x11,
0x6D, 0x48, 0x4D, 0x9F, 0xD9, 0x1D, 0x96, 0x4A,
0xE8, 0x36, 0x92, 0xE0, 0x25, 0x6C, 0x78, 0xE2,
0x7F, 0xB4, 0x0E, 0xEB, 0x3B, 0x6B, 0x1A, 0x2E,
0xA3, 0x4D, 0x18, 0x22, 0xF4, 0x54, 0xB7, 0xB3,
0xD7, 0x69, 0xDB, 0x86, 0x5A,
0x7A, 0x0F, 0x12, 0xA8, 0xD9, 0xED, 0x2A, 0xE3,
0x26, 0x10, 0x01, 0x46, 0x32, 0x86, 0xA3, 0x72,
0x27, 0x04, 0x3A, 0x26, 0xDF, 0x21, 0x25, 0x8D,
0x9C, 0x08, 0x59, 0xEE, 0xA6, 0x3C, 0xDB, 0xD4,
0x5D, 0x6E, 0xC4, 0x16, 0x25, 0x09, 0x37, 0x72,
0x40, 0x3D, 0xBE, 0x04, 0x60, 0xDD, 0xD3, 0xFA,
0xC9, 0xFF, 0x33, 0x09, 0x6E, 0x42, 0x95, 0x65,
0x56, 0x4D, 0x5A, 0xB0, 0x53, 0xA8, 0xF2, 0xC0,
0xCA, 0x09, 0x1D, 0xE2, 0xBB, 0x4F, 0xC3, 0x19,
0x95, 0x03, 0x88, 0xEB, 0x04, 0x81, 0xEC, 0xAB,
0xE6, 0x0E, 0xAE, 0x99, 0x11, 0x85, 0x99, 0x91,
0x95, 0xB7, 0x73, 0xBC, 0x54, 0xD9,
0x5A, 0x8E, 0xD3, 0xCE, 0x2A, 0xA2, 0xEE, 0x3B,
0x48, 0x98, 0x54, 0xFD, 0x75, 0x49, 0x95, 0x2D,
0x9E, 0xD0, 0xDE, 0x1E, 0xD2, 0x56, 0x88, 0x31,
0xDB, 0xCE, 0x98, 0x1C, 0x75, 0xDE, 0x44, 0x1D,
0x4B, 0xD5, 0xE3, 0x1E, 0x9E, 0x58, 0xB0, 0xC9,
0x52, 0x2E, 0x9D, 0x8F, 0xEF, 0x34, 0x96, 0x89,
0x65, 0x8F, 0x52, 0x29, 0xFA, 0x8B, 0xD7, 0x0A,
0xBE, 0xFE, 0x5C, 0xD9, 0x7C, 0x34, 0xB5, 0x32,
0xF1, 0x40, 0x64, 0xD0, 0xA0, 0x46, 0x7C, 0xB4,
0xBE, 0x1B, 0x97, 0xFA, 0x64, 0xCB, 0x0F, 0x77,
0x19, 0x77, 0xCC, 0x2A, 0x2F, 0x5D, 0x7E, 0x30,
0x7C, 0x8B, 0xE8, 0x5A, 0x1C, 0x14, 0xB9,
0x6D, 0x73, 0x03, 0x46, 0x6A, 0x95, 0xE6, 0x63,
0xF1, 0x7C, 0x15, 0xAF, 0x08, 0x12, 0xD1, 0x44,
0xC9, 0x7E, 0x84, 0xCF, 0xE4, 0x33, 0xD4, 0x23,
0x24, 0x19, 0x03, 0xE4, 0x4D, 0xC2, 0x4D, 0x0F,
0x1D, 0x5D, 0xE0, 0xE1, 0x84, 0x98, 0x71, 0x38,
0x45, 0xCF, 0x15, 0x57, 0x2A, 0x1C, 0x3F, 0xD8,
0xA6, 0x21, 0x5E, 0xEF, 0x1A, 0xDE, 0x97, 0x95,
0xE3, 0x29, 0xD7, 0xD2, 0x5A, 0x08, 0xE5, 0xD9,
0x89, 0x33, 0x62, 0x82, 0x2A, 0xA9, 0x11, 0x73,
0x6A, 0x2C, 0xD4, 0x58, 0xC7, 0xBB, 0xCD, 0x6A,
0x03, 0x51, 0x48, 0x37, 0xEC, 0x92, 0xCC, 0xBE,
0x34, 0x6D, 0xB8, 0x2E, 0x1F, 0x0B, 0xE4, 0x74,
0xBE, 0xD0, 0x1E, 0xF8, 0xB9, 0x6A, 0x92, 0x5C,
0xFC, 0x3A, 0x8D, 0x19, 0x88, 0x68, 0x55, 0xC9,
0xB9, 0xC3, 0xAF, 0xED, 0x5A, 0xF6, 0x48, 0x23,
0x64, 0x7B, 0x0F, 0x69, 0xD6, 0x9C, 0xA2, 0x73,
0xAF, 0xFA, 0x32, 0x82, 0x4A, 0xB6, 0x1D, 0x30,
0xDE, 0xAE, 0x09, 0x80, 0x77, 0x74, 0x42, 0x6E,
0x3E, 0x21, 0x0C, 0x25, 0xD9, 0xC6, 0x17, 0x7D,
0x7B, 0x6B, 0x4D, 0xA8, 0xB2, 0x14, 0x87, 0x5F,
0xBE, 0x35, 0x0A, 0x7E, 0x3C, 0xE2, 0x5C, 0x3E,
0x72, 0x54, 0x4A, 0xB3, 0x44, 0x13, 0x16, 0x78,
0x26, 0x16, 0xC3, 0x81, 0x6D, 0x20, 0x0E, 0xF6,
0x6B, 0x69, 0x0F, 0xBC, 0xA1, 0xFB, 0x45, 0xBE,
0xAE,
0xA5, 0x66, 0xC5, 0xED, 0x9E, 0xB6, 0xC6, 0xED,
0x4F, 0xA7, 0x13, 0x63, 0xE3, 0x09, 0x10, 0x3D,
0x86, 0xAB, 0x0D, 0x43, 0x4E, 0xC1, 0x94, 0xBF,
0x64, 0xA1, 0x30, 0x50, 0x1D, 0xC4, 0x3C, 0x27,
0x39, 0xE7, 0xE0, 0xD2, 0x3A, 0x50, 0x61, 0x0C,
0x2C, 0x27, 0xAF, 0xD0, 0xC3, 0x01, 0x82, 0x8A,
0x6D, 0x54, 0x00, 0x3F, 0xB8, 0xFF, 0x2B, 0x09,
0xF1, 0x99, 0xCC, 0x67, 0x72, 0x4E, 0x3B, 0x82,
0x4A, 0x2B, 0x6F, 0xE2, 0x35, 0xC2, 0x22, 0x2A,
0x25, 0x55, 0x68, 0x31, 0xD0, 0x75, 0x49, 0xB9,
0xBD, 0xAF, 0xA3, 0x55, 0xAB, 0x8A, 0x4E, 0x32,
0xE4, 0x5A, 0xA1, 0xB3, 0xB1, 0x02, 0x11, 0xD8,
0xCC, 0x20,
0x47, 0x42, 0xA4, 0x9B, 0x51, 0x38, 0x87, 0x6D,
0x3A, 0x21, 0x17, 0x31, 0xF5, 0x79, 0x48, 0x8C,
0x3D, 0xD7, 0x6E, 0xCC, 0xF2, 0x09, 0x3E, 0x2B,
0x5D, 0x69, 0x79, 0x43, 0x29, 0x02, 0x9C, 0xAA,
0x15, 0xD0, 0x4B, 0x32, 0xAD, 0x61, 0xEA, 0x00,
0xF0, 0x22, 0xAD, 0x7A, 0x12, 0xAF, 0xDE, 0xFB,
0x55, 0x38, 0xD8, 0xA9, 0x3F, 0x09, 0x34, 0xAF,
0x4C, 0x42, 0xD4, 0x20, 0x69, 0x7C, 0x0C, 0xBA,
0x34, 0xE3, 0xA5, 0xB8, 0x11, 0x43, 0x10, 0x41,
0xC9, 0x1A, 0x59, 0x74, 0x18, 0x5F, 0x3B, 0xB2,
0xA2, 0xA6, 0x9A, 0x4C, 0x23, 0x9F, 0x3F, 0xD8,
0x33, 0x64, 0x41, 0x84, 0xBF, 0x8D, 0x06, 0x12,
0x1E, 0x56, 0x67,
0x50, 0x7D, 0x3F, 0xA5, 0x4F, 0x79, 0xCE, 0xF9,
0xAE, 0x64, 0xC4, 0xC9, 0x59, 0x9C, 0x2D, 0x8E,
0x86, 0xDD, 0xC8, 0xAA, 0xE7, 0x1A, 0x21, 0xB6,
0x80, 0x23, 0xF4, 0xB1, 0xD0, 0x9E, 0x57, 0xCE,
0x08, 0xAB, 0x0D, 0xB8, 0xB0, 0xA8, 0x06, 0xD8,
0xE6, 0xA8, 0xD6, 0x31, 0xF8, 0x45, 0x62, 0xDF,
0x71, 0x41, 0x25, 0xB7, 0xEB, 0x3A, 0xFC, 0x93,
0x63, 0x49, 0x36, 0x07, 0x8F, 0x18, 0x3A, 0x1F,
0x1C, 0xA3, 0xCB, 0x90, 0xED, 0x68, 0x47, 0x58,
0xB9, 0xB6, 0x85, 0x8A, 0x2B, 0x05, 0xA7, 0x25,
0x03, 0xD2, 0x36, 0xF7, 0x04, 0xE4, 0xA3, 0xE2,
0x7F, 0xEE, 0x09, 0x6C, 0x57, 0xBB, 0xC0, 0x02,
0x21, 0xC3, 0xF5, 0x2F,
0xA8, 0x9B, 0xC0, 0x79, 0x9F, 0xC0, 0xEF, 0x00,
0xD4, 0x30, 0x90, 0xF2, 0xDB, 0xD6, 0x08, 0x36,
0x87, 0x38, 0xFF, 0x57, 0xC0, 0xB3, 0x91, 0x42,
0x4F, 0xE8, 0x11, 0xF5, 0xD6, 0x3E, 0xCE, 0xEA,
0x62, 0x23, 0xDA, 0x0C, 0x98, 0xF8, 0xEA, 0xA3,
0xC9, 0x21, 0xF6, 0x03, 0xD4, 0x71, 0x79, 0x6A,
0xE4, 0x2A, 0x0D, 0xF2, 0xD7, 0xF2, 0xE4, 0x04,
0xF3, 0xB7, 0xAD, 0x9D, 0xF5, 0xB4, 0xDC, 0x58,
0xF3, 0x6C, 0xE3, 0x95, 0xDE, 0xA8, 0x9F, 0x60,
0x59, 0xDF, 0x67, 0xC6, 0x47, 0xF7, 0x05, 0xE1,
0x6C, 0xDE, 0x50, 0x35, 0x35, 0x14, 0x22, 0xC1,
0x74, 0x7F, 0xE7, 0xB4, 0xA9, 0x51, 0x3F, 0x54,
0x9A, 0x89, 0x31, 0xFF, 0xDD,
0x05, 0xDC, 0xD4, 0xC5, 0xDB, 0xCD, 0x66, 0x3A,
0xC7, 0x70, 0x43, 0x83, 0x38, 0x21, 0x1C, 0x17,
0xB8, 0xC5, 0x59, 0x0D, 0x5E, 0x68, 0xF9, 0x1E,
0x10, 0xD7, 0x88, 0xB1, 0x61, 0x31, 0x7D, 0x10,
0x11, 0x27, 0xA2, 0x9E, 0x27, 0x99, 0x27, 0x66,
0x37, 0x6F, 0x2F, 0x2C, 0x43, 0xE4, 0x0C, 0xAA,
0x69, 0xEC, 0x9B, 0xE0, 0x99, 0xE8, 0x0B, 0x61,
0xDD, 0x6F, 0x97, 0xC2, 0x83, 0x6A, 0xE2, 0x98,
0x73, 0xA1, 0xB6, 0x84, 0x78, 0x16, 0xBD, 0xB5,
0x38, 0x39, 0x90, 0x9E, 0x30, 0x92, 0x5C, 0x4B,
0x0D, 0x7C, 0x45, 0xCE, 0x9B, 0x8A, 0xB1, 0x83,
0x41, 0xF0, 0x01, 0xBD, 0xFB, 0x5D, 0x61, 0x9A,
0xBE, 0x5C, 0x57, 0x33, 0xA5, 0xAC,
0xE6, 0x66, 0xF6, 0xF0, 0x8A, 0xD1, 0x3F, 0x25,
0xEB, 0xC4, 0x97, 0x47, 0x9A, 0x3D, 0xA4, 0xDE,
0x54, 0xC3, 0x71, 0xBE, 0x82, 0xD3, 0x4B, 0x41,
0xD4, 0x24, 0x38, 0xFE, 0x5A, 0x5B, 0x17, 0xE0,
0x6B, 0x7C, 0x01, 0xF0, 0xFF, 0x19, 0xF5, 0x07,
0xC3, 0xDA, 0x0F, 0x90, 0x41, 0x95, 0x00, 0xD2,
0xFB, 0x02, 0xB1, 0xAC, 0xDC, 0xA1, 0x03, 0xA1,
0xCD, 0x16, 0x12, 0xF1, 0x3A, 0xA8, 0x30, 0x53,
0x6C, 0x2A, 0x75, 0xDC, 0xA4, 0xAC, 0x76, 0xB3,
0x07, 0x8F, 0xB9, 0x32, 0x13, 0xF1, 0x79, 0xDA,
0x0A, 0x47, 0xF9, 0xF0, 0xCB, 0xEE, 0x62, 0x8D,
0x07, 0xF6, 0x06, 0xA3, 0xA3, 0xAA, 0xB3, 0x63,
0x63, 0xFB, 0xDE, 0x1A, 0x74, 0x7B, 0x79,
0xBF, 0x02, 0xFC, 0xAA, 0x8C, 0x22, 0x0E, 0x02,
0xD1, 0xD6, 0x57, 0x92, 0x43, 0xEB, 0x41, 0xBD,
0x1F, 0x49, 0x3D, 0x63, 0x25, 0x4A, 0x2B, 0x7F,
0xEF, 0x0E, 0x03, 0xA9, 0x40, 0x17, 0xA0, 0x7E,
0x2C, 0x17, 0x38, 0xB0, 0x16, 0xA9, 0xD4, 0xCC,
0xD8, 0x75, 0x60, 0x3B, 0x7C, 0x5F, 0x2E, 0xE0,
0xBD, 0x28, 0x25, 0xCB, 0xA4, 0x9D, 0xCE, 0x82,
0x81, 0xDB, 0xD9, 0xEB, 0x8B, 0xD2, 0x60, 0xC5,
0x4D, 0x48, 0xD7, 0x5C, 0xD0, 0xAB, 0x4D, 0x8B,
0x65, 0x90, 0x01, 0xCE, 0x53, 0x09, 0xA3, 0x30,
0x6B, 0x40, 0x59, 0x7B, 0xCE, 0x78, 0xC6, 0x8F,
0xBA, 0x7A, 0xB1, 0x1B, 0xA9, 0xBF, 0x51, 0xE3,
0x84, 0x3E, 0x93, 0x33, 0x82, 0x7E, 0x8A, 0xA3,
0x75, 0x4B, 0x38, 0x79, 0xF7, 0x5A, 0x23, 0x8A,
0x28, 0x45, 0x07, 0x1D, 0x38, 0xC8, 0x44, 0x4E,
0x8B, 0xB1, 0xFF, 0x08, 0x86, 0xDA, 0xDA, 0x4C,
0x1C, 0x2D, 0xA5, 0x50, 0xE6, 0x81, 0x12, 0x9A,
0x62, 0x12, 0x41, 0x9D, 0xE9, 0x84, 0x11, 0xBC,
0xA9, 0x20, 0xA5, 0xAF, 0xED, 0x4C, 0xFE, 0x80,
0x38, 0x72, 0x08, 0x6C, 0xF7, 0x0D, 0x83, 0xC1,
0xF0, 0x76, 0x6F, 0x99, 0x4D, 0xCA, 0x98, 0x21,
0xF3, 0xC8, 0xF4, 0x48, 0xD2, 0xC9, 0x10, 0x7B,
0x27, 0x75, 0xB9, 0xE8, 0x25, 0x3D, 0x85, 0xAF,
0x1D, 0xCF, 0x2E, 0x19, 0x81, 0x2C, 0x86, 0x5C,
0xBE, 0x67, 0x51, 0x16, 0x48, 0x74, 0xF8, 0xC8,
0xA1, 0x72, 0xB5, 0xF0, 0x2B, 0xB7, 0x5F, 0x9A,
0xC9,
0x2E, 0xB9, 0x2B, 0x7B, 0xED, 0x0F, 0x81, 0xB5,
0x17, 0xC7, 0x0E, 0x3B, 0x31, 0x61, 0xDC, 0x12,
0xE6, 0x75, 0x03, 0x8D, 0x6B, 0xE6, 0x73, 0x0C,
0xFB, 0xEC, 0x93, 0x47, 0xB2, 0x2E, 0x4F, 0xC6,
0x9E, 0x3C, 0xA9, 0x75, 0x49, 0xB2, 0xC2, 0x37,
0xA8, 0x4D, 0xE6, 0xA4, 0x4A, 0x31, 0xF3, 0x48,
0x1D, 0xF7, 0x24, 0x01, 0x97, 0xDA, 0x64, 0xBA,
0x0F, 0x39, 0x25, 0x95, 0x2C, 0x7A, 0x84, 0x77,
0xF8, 0x7B, 0x71, 0xAE, 0xE9, 0xA6, 0x80, 0x34,
0x38, 0xA4, 0x2C, 0xFB, 0xED, 0x5A, 0xD8, 0x45,
0x50, 0x16, 0xBA, 0xBC, 0xD4, 0xFC, 0xE5, 0x98,
0x4F, 0xA1, 0xA8, 0x21, 0x7E, 0x87, 0xF5, 0x4E,
0x6E, 0x5F, 0xCF, 0xBE, 0xC3, 0x62, 0xA2, 0x91,
0x8E, 0x77,
0x0A, 0xFB, 0xBA, 0xE5, 0x0A, 0x2F, 0x0B, 0x10,
0x61, 0xD1, 0x03, 0x33, 0x64, 0xE0, 0x50, 0xB0,
0x3D, 0x3A, 0x26, 0x36, 0xAC, 0xDF, 0xD2, 0x50,
0x6E, 0xB0, 0x78, 0x55, 0xBD, 0xAB, 0x41, 0xB9,
0x8A, 0x91, 0x26, 0x55, 0x2A, 0xB9, 0x35, 0x3B,
0xFC, 0x4E, 0x8E, 0x7F, 0x60, 0xFB, 0x57, 0x12,
0xAF, 0xFD, 0xAE, 0x80, 0x84, 0x1C, 0x63, 0x20,
0x68, 0xF5, 0x77, 0x0D, 0x11, 0xF8, 0xFD, 0x16,
0x41, 0x8A, 0x0C, 0x0A, 0x70, 0x39, 0xED, 0x58,
0x91, 0x04, 0x05, 0xC6, 0xCF, 0xA9, 0x17, 0x03,
0xB0, 0x67, 0x8A, 0x12, 0x7D, 0x32, 0xDB, 0x68,
0xA4, 0x48, 0xE2, 0x2C, 0xEF, 0x23, 0x93, 0x1C,
0x3D, 0xDA, 0xA4, 0xB5, 0xD5, 0x61, 0xF4, 0x6A,
0xEA, 0xE5, 0xB1,
0x2D, 0x14, 0xF7, 0x07, 0x0B, 0xFB, 0xAE, 0x8F,
0x16, 0xC9, 0xFD, 0x23, 0xBD, 0xD8, 0x96, 0x22,
0x59, 0x5A, 0x9C, 0x72, 0xD3, 0xA9, 0xF9, 0xC9,
0xD5, 0xC8, 0x72, 0x33, 0x8A, 0xDF, 0x2D, 0xF7,
0xA5, 0x5C, 0x9E, 0xE7, 0x7D, 0x08, 0xBF, 0x49,
0xDD, 0x01, 0xE0, 0x36, 0x32, 0x8D, 0xAC, 0xA0,
0xD4, 0xF7, 0x8F, 0x3B, 0xD8, 0x56, 0xB2, 0x03,
0x42, 0x72, 0x87, 0xF6, 0xA8, 0x57, 0x49, 0x9A,
0x76, 0xF3, 0xDE, 0xB6, 0x4A, 0xCC, 0xEC, 0x8D,
0xE9, 0x6F, 0x22, 0x1A, 0xFF, 0x5A, 0xEC, 0x0F,
0x40, 0xB7, 0x96, 0x08, 0x70, 0xEB, 0x2B, 0xB4,
0x2C, 0xDC, 0x69, 0x54, 0xC9, 0x95, 0xF0, 0x1E,
0x43, 0xC2, 0x16, 0x2C, 0xC6, 0xAD, 0xF4, 0xC9,
0x1A, 0xEE, 0xBA, 0xE8,
0xFF, 0x07, 0x0B, 0x99, 0xF2, 0x29, 0x7A, 0xBF,
0x77, 0x8E, 0x35, 0x03, 0x16, 0x88, 0xBF, 0xAB,
0xBC, 0x6C, 0x31, 0x80, 0x1B, 0xF1, 0x34, 0x06,
0x47, 0x70, 0x7E, 0x98, 0x42, 0x92, 0xD5, 0xFF,
0x23, 0x21, 0x57, 0x5E, 0x97, 0xA7, 0x7C, 0xD7,
0x75, 0xBD, 0x31, 0x82, 0xF9, 0xD9, 0x6D, 0xF1,
0x98, 0x17, 0xB0, 0x93, 0xDF, 0xA3, 0x6F, 0x37,
0x11, 0x41, 0x5D, 0x54, 0xCD, 0x5F, 0xD7, 0x07,
0x5F, 0x43, 0x53, 0x66, 0x04, 0x71, 0x24, 0xC5,
0x9A, 0x2D, 0xCE, 0x8C, 0x7B, 0x29, 0x00, 0x2E,
0x02, 0x2B, 0x5A, 0x6D, 0x87, 0x01, 0x50, 0xFF,
0xF2, 0x06, 0xA0, 0x9F, 0x9C, 0x50, 0x54, 0xB6,
0x02, 0xB7, 0x88, 0x99, 0x24, 0xAA, 0x1F, 0x2B,
0x65, 0x54, 0x6F, 0xB8, 0xF0,
0x79, 0xB8, 0xC3, 0x4E, 0x02, 0xE0, 0xE4, 0xB7,
0x95, 0x74, 0x8A, 0xFD, 0xD4, 0xE2, 0x3B, 0x6B,
0xA4, 0xC9, 0x3B, 0x52, 0xFE, 0xAA, 0x15, 0x71,
0x63, 0xE2, 0x9A, 0x19, 0x89, 0xE1, 0x64, 0x06,
0xC7, 0xA6, 0x3E, 0x0B, 0x2B, 0x0B, 0xB9, 0x28,
0x88, 0x3B, 0x07, 0x7B, 0x55, 0x8B, 0x69, 0x14,
0xF4, 0x54, 0xC0, 0x1B, 0x90, 0x9B, 0x92, 0x56,
0xB9, 0x8F, 0x66, 0x16, 0x8B, 0x67, 0x2E, 0xF5,
0xF8, 0x06, 0x3D, 0x33, 0xB6, 0x5B, 0x7A, 0x69,
0xA4, 0x46, 0x73, 0x66, 0x2B, 0x43, 0x6D, 0xFA,
0x4B, 0x30, 0x85, 0xE6, 0x5C, 0x91, 0xE1, 0xC6,
0x46, 0x10, 0x98, 0xF2, 0xEE, 0xEF, 0xCB, 0x4E,
0xB1, 0x70, 0xF8, 0xA0, 0xD5, 0x86, 0xC6, 0x77,
0xD7, 0x53, 0xC0, 0x9E, 0xA0, 0xD8,
0x97, 0xB9, 0xA6, 0xFD, 0xB3, 0xD4, 0xAA, 0x8F,
0xC2, 0x45, 0x7A, 0xF5, 0x13, 0x73, 0xA8, 0x80,
0x4F, 0x39, 0x59, 0x3A, 0x2D, 0xCA, 0x18, 0x88,
0x94, 0x8B, 0xC5, 0x3C, 0x4E, 0x15, 0xE4, 0x0A,
0xB1, 0xD8, 0x3D, 0xA0, 0xC1, 0x3E, 0x9F, 0x93,
0x08, 0x33, 0x58, 0x69, 0x1E, 0xEC, 0xF6, 0xDD,
0xBE, 0x4B, 0x89, 0x43, 0x03, 0x74, 0xAA, 0x6B,
0xEE, 0xC2, 0x1B, 0x72, 0xC6, 0x44, 0xAC, 0x1C,
0x4E, 0x89, 0xB9, 0x08, 0x25, 0x32, 0x69, 0xC4,
0x27, 0x8E, 0x44, 0xEA, 0x57, 0xE6, 0x02, 0x49,
0x4B, 0x03, 0xCB, 0x02, 0xEA, 0xDC, 0xE9, 0xF6,
0x2C, 0x27, 0x5E, 0xD9, 0x96, 0xC8, 0xC9, 0x58,
0x4A, 0x2A, 0xC8, 0x36, 0xDC, 0xC3, 0x1E, 0x83,
0x02, 0x79, 0x41, 0xDF, 0x18, 0x18, 0x19,
0xA5, 0x23, 0xAA, 0xC4, 0x3C, 0x45, 0x39, 0x82,
0x71, 0x3E, 0x3A, 0x57, 0x41, 0x0B, 0x2C, 0x7E,
0xBE, 0x06, 0x86, 0xD4, 0x9F, 0xB9, 0x1C, 0x60,
0x5E, 0xB7, 0x11, 0xB1, 0xC6, 0xD6, 0xF3, 0x3E,
0x20, 0x55, 0x1E, 0x23, 0xFE, 0x65, 0x0F, 0xF3,
0xD7, 0x82, 0x4C, 0xE5, 0x90, 0x95, 0xF2, 0x17,
0x31, 0xC4, 0x37, 0xC5, 0xE8, 0x3A, 0xF0, 0x92,
0x7C, 0x34, 0x7A, 0xD2, 0x16, 0x90, 0xD4, 0xBB,
0x5F, 0x7C, 0x6E, 0xD1, 0x68, 0xC2, 0xA7, 0x51,
0x04, 0x66, 0x3D, 0x78, 0xE9, 0x31, 0xF7, 0x4A,
0xE3, 0x8F, 0x6F, 0xCA, 0xC5, 0xEE, 0x28, 0xE7,
0x05, 0xAF, 0x29, 0x1E, 0x41, 0x3E, 0x83, 0xE3,
0xF4, 0xEA, 0xF2, 0xD2, 0xAF, 0x59, 0x57, 0x51,
0x44, 0x71, 0xF0, 0x05, 0x72, 0x9C, 0xBF, 0x92,
0x8F, 0x24, 0xFA, 0x4E, 0x3C, 0x12, 0xAF, 0x30,
0xB6, 0x95, 0x5E, 0x81, 0x48, 0xB2, 0xBA, 0xFA,
0x64, 0xFC, 0xF0, 0x95, 0xD2, 0x2A, 0x13, 0x3F,
0x56, 0xE3, 0x63, 0x9E, 0x73, 0x68, 0xCF, 0x74,
0x13, 0xCF, 0x2C, 0xC5, 0x2D, 0x90, 0x6E, 0x45,
0x94, 0x2F, 0x99, 0x29, 0xDE, 0x29, 0x1C, 0xED,
0x3C, 0xB6, 0x17, 0x68, 0x97, 0xB3, 0xB0, 0xC5,
0x52, 0xF8, 0x34, 0xB1, 0x36, 0x15, 0x0E, 0xC7,
0xBE, 0x55, 0xC0, 0xCD, 0x16, 0x1F, 0xBB, 0x95,
0x30, 0xC0, 0x2E, 0x27, 0x3E, 0x49, 0xBC, 0x8C,
0x55, 0x19, 0xC9, 0x4A, 0x4A, 0x9F, 0x27, 0x63,
0xB9, 0xFB, 0x04, 0x77, 0x83, 0x0F, 0xAD, 0xF9,
0x36, 0x2D, 0xA7, 0x7D, 0x36, 0x02, 0x34, 0xA6,
0x2F, 0x87, 0x80, 0xCB, 0x86, 0xA9, 0x89, 0xCD,
0x66,
0xA0, 0x24, 0xCB, 0x5F, 0x83, 0xC0, 0xFE, 0x64,
0x03, 0x0A, 0xA2, 0x1D, 0x9A, 0x0E, 0x25, 0x08,
0x23, 0x7C, 0x78, 0x59, 0x26, 0xFC, 0x07, 0x41,
0xD9, 0xC4, 0x0D, 0x4C, 0x65, 0x28, 0x73, 0x78,
0xB6, 0x3D, 0x92, 0x38, 0xEE, 0x44, 0x5B, 0x7A,
0x5D, 0xD4, 0x4F, 0x44, 0xAE, 0x5C, 0xF8, 0x34,
0x3E, 0xD3, 0xBC, 0x51, 0xDF, 0x76, 0x49, 0x8D,
0x97, 0xE1, 0x5D, 0x48, 0xAE, 0xE4, 0x11, 0x97,
0xC9, 0xAB, 0x0A, 0xC2, 0xF1, 0x2F, 0x93, 0x36,
0x3B, 0x98, 0x58, 0x98, 0xD1, 0x9C, 0xA6, 0x2A,
0x47, 0x73, 0xAC, 0x41, 0xF1, 0xC9, 0xD6, 0xE2,
0x91, 0x31, 0xD5, 0x19, 0x06, 0x67, 0x6D, 0xF8,
0x6B, 0xCD, 0x7D, 0x5E, 0xCE, 0xFF, 0x23, 0x1D,
0x69, 0xB7, 0x93, 0xEA, 0xDB, 0x5B, 0x21, 0x7A,
0x76, 0xBC,
0x1A, 0x15, 0xDC, 0x87, 0xDD, 0x83, 0xEB, 0x69,
0xF9, 0x6F, 0x09, 0xD7, 0x22, 0x8C, 0x5D, 0xE0,
0x94, 0xC1, 0x7F, 0x96, 0x3F, 0x61, 0x3C, 0x9A,
0x33, 0x45, 0x52, 0x1B, 0x9B, 0x2B, 0x22, 0x96,
0x0C, 0xBA, 0xB7, 0xD5, 0x75, 0x26, 0x0E, 0x6A,
0x58, 0x9E, 0xCE, 0x21, 0x51, 0x44, 0x3B, 0x67,
0x63, 0xAD, 0x83, 0xA1, 0xCD, 0x73, 0x12, 0x2A,
0xFB, 0x39, 0x65, 0xBD, 0x06, 0xA1, 0x32, 0x73,
0x91, 0x4A, 0x47, 0xB6, 0x24, 0xBF, 0x7B, 0xE5,
0x35, 0x4F, 0x9C, 0x48, 0xA7, 0xDC, 0x31, 0x48,
0xAA, 0x8E, 0x6A, 0xA8, 0x35, 0x59, 0x71, 0x54,
0x5C, 0x62, 0x29, 0xE9, 0xD2, 0xE2, 0xB7, 0x3A,
0xE8, 0x7A, 0x82, 0x48, 0xC9, 0x7B, 0x66, 0xC9,
0x78, 0x5B, 0xC4, 0xB2, 0x1C, 0x29, 0x50, 0xFF,
0x29, 0xCF, 0x24,
0x94, 0x28, 0xE6, 0x7F, 0xBA, 0x33, 0xF4, 0x6D,
0x99, 0xF9, 0x05, 0x7E, 0x1F, 0x55, 0xBB, 0x26,
0x06, 0x36, 0x5F, 0xC1, 0xE9, 0xE0, 0x75, 0x9D,
0x5B, 0xE4, 0x74, 0xF0, 0x51, 0x49, 0xB4, 0xEC,
0x4A, 0x19, 0xD0, 0xA8, 0xD3, 0xF8, 0xE9, 0xA6,
0xD7, 0x05, 0xD9, 0x4F, 0x39, 0x1C, 0xD1, 0x6E,
0xEA, 0xB0, 0x50, 0xC3, 0x8B, 0xD9, 0xEA, 0x20,
0x57, 0x51, 0xFB, 0xF2, 0xBB, 0xE5, 0x24, 0x1A,
0xEB, 0x26, 0xE3, 0x27, 0x2E, 0x62, 0x1F, 0x90,
0x61, 0x51, 0x0B, 0x9E, 0x5B, 0x92, 0x09, 0x59,
0x37, 0x67, 0xFE, 0x72, 0xA6, 0xCE, 0x3D, 0xB8,
0x75, 0xD0, 0xC4, 0xDE, 0x0B, 0xFC, 0x59, 0x99,
0x59, 0x5C, 0x20, 0x44, 0x50, 0x6B, 0x09, 0x95,
0x3A, 0xEF, 0xC7, 0x68, 0x43, 0x4E, 0xB7, 0x1D,
0xE6, 0x36, 0xBF, 0x09,
0xA5, 0x15, 0xAA, 0x1F, 0xAC, 0xE4, 0x4A, 0x2E,
0x76, 0xE0, 0x97, 0xFB, 0xA1, 0x3F, 0x41, 0xDD,
0xAB, 0x64, 0x31, 0x4D, 0xA2, 0xEA, 0x8D, 0xDA,
0x4F, 0x07, 0x6F, 0x00, 0x1F, 0x3F, 0x71, 0x43,
0x15, 0x80, 0xFE, 0x13, 0xD4, 0xA7, 0x7B, 0x95,
0x63, 0xB4, 0x1C, 0xAA, 0xD1, 0x2B, 0x45, 0x70,
0x57, 0x7C, 0x0A, 0x0B, 0x5D, 0x5F, 0x90, 0x30,
0xB5, 0x43, 0xCD, 0xC3, 0x39, 0x59, 0x1B, 0xB0,
0xC2, 0x65, 0xCD, 0x86, 0x13, 0xB5, 0x29, 0xD5,
0xF7, 0xC5, 0x94, 0x2C, 0x27, 0x9C, 0x1C, 0x1B,
0x47, 0x8D, 0x7F, 0x11, 0x2D, 0x48, 0x4A, 0x50,
0x5B, 0x55, 0xE2, 0x4E, 0x69, 0xDB, 0x2C, 0x72,
0xE2, 0x46, 0xFA, 0x00, 0x08, 0x36, 0x7C, 0x34,
0x28, 0x02, 0x43, 0x78, 0x36, 0x73, 0x0C, 0x01,
0x1D, 0x4A, 0xA8, 0x4C, 0xDF,
0x4A, 0xFE, 0x5C, 0xB4, 0xB2, 0x1C, 0xE9, 0x4B,
0x64, 0xA9, 0xEA, 0xDE, 0x9E, 0xFD, 0x52, 0x4C,
0xEE, 0x01, 0xCE, 0x11, 0xA0, 0x54, 0x89, 0x88,
0xDE, 0x0C, 0x43, 0x32, 0x12, 0xCB, 0x2C, 0x9B,
0xCE, 0xEB, 0xD3, 0xBF, 0x3D, 0xDF, 0x63, 0x0F,
0x90, 0xBA, 0xD9, 0x0A, 0xC5, 0xB1, 0x0E, 0xE2,
0x90, 0x00, 0x90, 0xA5, 0x3B, 0xD1, 0x96, 0xED,
0x76, 0x92, 0x6D, 0x10, 0xF3, 0xB9, 0xC8, 0xBC,
0xBB, 0x40, 0x80, 0x25, 0x58, 0xFC, 0xB2, 0x23,
0x74, 0x9A, 0x02, 0x13, 0x4C, 0x1A, 0x13, 0x9E,
0x5D, 0x1D, 0x1B, 0xB7, 0x97, 0x37, 0xAD, 0x3B,
0xA7, 0x92, 0x48, 0x47, 0x62, 0x2E, 0xA8, 0x28,
0x36, 0x3E, 0xB5, 0x71, 0xA2, 0x5D, 0xFC, 0xB4,
0x0D, 0xBF, 0x28, 0x7D, 0x1A, 0x8C, 0x99, 0x78,
0xF3, 0x46, 0x3C, 0x61, 0xAB, 0xC1,
0xBC, 0xD6, 0x19, 0xA0, 0x63, 0x64, 0x51, 0xE7,
0x87, 0x4E, 0x2C, 0x0F, 0xE0, 0x84, 0xA8, 0x18,
0x89, 0xD9, 0x8B, 0x1E, 0x78, 0x06, 0x07, 0xA7,
0xA8, 0x42, 0xD5, 0x8E, 0x06, 0x15, 0x8E, 0xC5,
0xCE, 0x94, 0x6B, 0x93, 0x78, 0x4C, 0x48, 0xD3,
0x92, 0xAA, 0x82, 0x81, 0xF6, 0x0E, 0x10, 0xAC,
0x3E, 0x7C, 0x76, 0xC0, 0xA4, 0xB2, 0xDA, 0x57,
0xE5, 0xAE, 0xC9, 0xE8, 0x16, 0xBE, 0x1F, 0x12,
0x3F, 0x1D, 0x27, 0x12, 0x01, 0x3D, 0xA1, 0xF7,
0x27, 0x3C, 0xDB, 0x9D, 0x7B, 0x85, 0xC5, 0x16,
0x96, 0x4A, 0x00, 0xBD, 0xBE, 0x98, 0x65, 0xA8,
0xAB, 0x61, 0x76, 0x5E, 0xC1, 0x2E, 0x43, 0xE4,
0xBD, 0xEE, 0xEE, 0x4F, 0x6E, 0x67, 0x13, 0x4C,
0x27, 0x77, 0xE1, 0xBE, 0x75, 0x70, 0x38, 0xB3,
0xAC, 0x00, 0x2A, 0x7C, 0x8C, 0x6B, 0x09,
0x32, 0x00, 0x61, 0x4A, 0xF8, 0xA8, 0x67, 0xA1,
0x68, 0x8D, 0x41, 0x28, 0x26, 0x76, 0xA8, 0x95,
0xD0, 0xF5, 0x71, 0xC6, 0x91, 0x59, 0x46, 0x98,
0xFB, 0xB9, 0x23, 0xBB, 0x8B, 0x57, 0xAB, 0x4E,
0x53, 0x37, 0x8C, 0x82, 0x52, 0xB8, 0x2B, 0x74,
0x3B, 0xDE, 0xB6, 0xED, 0xF1, 0xC9, 0x6A, 0x77,
0xEE, 0xD6, 0x28, 0x0E, 0xA0, 0xA9, 0xB5, 0xE4,
0xB8, 0x75, 0x98, 0xC9, 0xA5, 0x04, 0xB5, 0x45,
0x53, 0x39, 0x9C, 0x8C, 0x5E, 0x95, 0xC4, 0x4C,
0xE1, 0x92, 0xEC, 0xB5, 0x22, 0xF0, 0x39, 0xB2,
0x41, 0xA2, 0xE6, 0x0F, 0x13, 0x28, 0xE8, 0x3D,
0x49, 0xB8, 0xD0, 0xCB, 0xBB, 0x1C, 0x88, 0x3F,
0x03, 0x48, 0xAB, 0xE8, 0x70, 0xAB, 0x3F, 0xEB,
0x77, 0x1F, 0x14, 0xD8, 0xC0, 0xAF, 0x69, 0xF2,
0x05, 0xAD, 0x08, 0x75, 0xA8, 0xA2, 0x0D, 0x7A,
0x99, 0x30, 0xBB, 0xF0, 0xBB, 0x99, 0x96, 0xF1,
0x66, 0x94, 0x2A, 0x59, 0x1E, 0x51, 0xA4, 0xDD,
0x05, 0xB0, 0x44, 0x58, 0xD2, 0x4E, 0x90, 0x0B,
0x0A, 0x28, 0xBE, 0x4C, 0x1E, 0xD3, 0x89, 0x2B,
0xEF, 0x23, 0xE9, 0x21, 0x17, 0x2F, 0xA5, 0xE3,
0xEC, 0xC0, 0x44, 0x9D, 0x4B, 0x77, 0xF8, 0xA6,
0x60, 0x19, 0x00, 0xDB, 0x47, 0x67, 0x65, 0x43,
0x9A, 0x89, 0xA8, 0x1F, 0xC6, 0x65, 0xCA, 0x57,
0xFF, 0x0F, 0xD4, 0x08, 0x95, 0x77, 0x92, 0x2F,
0xE5, 0x39, 0x5D, 0x21, 0xEE, 0x54, 0xE6, 0x7F,
0x35, 0x8C, 0xA6, 0x6C, 0xD2, 0xCC, 0x38, 0xF4,
0x13, 0x2E, 0x37, 0x42, 0x54, 0x1A, 0xF1, 0x55,
0x0A, 0x8A, 0x36, 0xA1, 0x86, 0x8E, 0x77, 0x74,
0x1B, 0x8E, 0xF7, 0xE9, 0x90, 0x3E, 0x15, 0x81,
0x75, 0xBE, 0xB2, 0x91, 0x75, 0x8B, 0x4E, 0x1D,
0x4F,
0x9C, 0xEB, 0x24, 0x43, 0x20, 0x8D, 0x4B, 0x67,
0xD9, 0x1E, 0x9A, 0xA3, 0xD3, 0x37, 0x08, 0xC1,
0x57, 0xE3, 0xEF, 0x14, 0xE2, 0xD1, 0x4C, 0x04,
0x46, 0x6B, 0x06, 0x86, 0x85, 0xB0, 0x1F, 0xE4,
0xBC, 0x40, 0x28, 0x55, 0x61, 0xFD, 0x68, 0x33,
0x38, 0x6F, 0x20, 0x54, 0xBA, 0xD1, 0x98, 0xAB,
0xD1, 0x09, 0xC7, 0xD5, 0x88, 0x86, 0x82, 0x81,
0x0C, 0x36, 0x56, 0x62, 0xC7, 0xD4, 0x48, 0xA5,
0x0D, 0xE9, 0xCD, 0x34, 0xB0, 0x46, 0xC4, 0xD9,
0x08, 0x28, 0xF9, 0x9B, 0xBF, 0xFE, 0xE3, 0xBD,
0x66, 0x3D, 0xF2, 0x88, 0xAB, 0xE0, 0xB8, 0x3F,
0x58, 0x9A, 0x9D, 0x28, 0xA1, 0x56, 0x1E, 0x63,
0x92, 0x36, 0x88, 0xE7, 0xE6, 0x58, 0xD9, 0x57,
0x88, 0x03, 0xAE, 0x7D, 0x6D, 0x11, 0xA6, 0xCB,
0x4F, 0xFD, 0x69, 0x64, 0xC1, 0xCA, 0x30, 0x6D,
0x4C, 0x22,
0xF2, 0x62, 0xB3, 0xE1, 0xF5, 0x42, 0xCF, 0xCF,
0x3D, 0x3B, 0xA2, 0xD0, 0x65, 0xBE, 0xB0, 0xEB,
0x9E, 0x16, 0x09, 0x55, 0x44, 0x0C, 0xE0, 0x78,
0xC8, 0xE3, 0x77, 0xEF, 0xA6, 0x15, 0x0A, 0xCA,
0xA6, 0xA0, 0x8F, 0x1D, 0x27, 0xDB, 0x73, 0x0E,
0x0E, 0x4A, 0xFD, 0xA8, 0x91, 0x40, 0xB2, 0xA5,
0x65, 0xFC, 0x66, 0xEE, 0x67, 0x7A, 0xA0, 0x24,
0x43, 0xBE, 0xE4, 0x1C, 0x5B, 0x13, 0xAE, 0xFF,
0x4C, 0xBF, 0x43, 0xCC, 0xD1, 0x5B, 0x05, 0x0E,
0x7B, 0xCF, 0x01, 0x75, 0xE8, 0x14, 0x81, 0x41,
0x7E, 0x88, 0x83, 0x73, 0x65, 0xE1, 0x6C, 0xA0,
0xA8, 0xBD, 0xE2, 0xE4, 0x59, 0xA1, 0x7F, 0x13,
0x0F, 0x72, 0x85, 0x3D, 0x07, 0x31, 0xE1, 0xC9,
0x26, 0x19, 0x6F, 0x46, 0x1F, 0x49, 0xB3, 0x76,
0xA8, 0x19, 0xD2, 0x07, 0xDD, 0xD0, 0x95, 0xA2,
0x81, 0xB1, 0xFE,
0x41, 0xFB, 0xCE, 0x5C, 0xBA, 0xB8, 0x30, 0x69,
0x5C, 0x9B, 0x46, 0xAB, 0x37, 0xC0, 0xE2, 0x70,
0x6C, 0x48, 0x18, 0x70, 0x97, 0x9F, 0xBB, 0x34,
0x50, 0x78, 0x66, 0x27, 0x6B, 0x37, 0xDD, 0x7C,
0x5D, 0xC7, 0xA8, 0xB5, 0xEE, 0x4F, 0x90, 0xAB,
0x3E, 0x34, 0x61, 0x34, 0x61, 0x40, 0x30, 0x0E,
0x2B, 0x51, 0xF1, 0xD9, 0x77, 0x2E, 0xF4, 0x27,
0x97, 0x1D, 0xF3, 0x1A, 0x89, 0x39, 0xAE, 0xC7,
0xCB, 0xE0, 0x6F, 0xA2, 0x89, 0xAE, 0x4E, 0x6C,
0x4D, 0x0C, 0xB5, 0x4B, 0xBB, 0xE5, 0xE0, 0xB0,
0xFA, 0x14, 0x4B, 0x16, 0xE0, 0x06, 0x87, 0x77,
0xC5, 0xC2, 0xFA, 0x57, 0xF0, 0x69, 0xE6, 0xC5,
0x51, 0x5D, 0x60, 0x3C, 0x44, 0x66, 0x7A, 0x9F,
0x6D, 0xC3, 0x2E, 0x8B, 0xE5, 0xCE, 0xB7, 0xF7,
0x0F, 0x97, 0xAB, 0xE5, 0x24, 0x45, 0x46, 0x66,
0xC9, 0x5E, 0xE2, 0x08,
0x40, 0x52, 0xA6, 0xA5, 0xFB, 0xF7, 0x1F, 0xFB,
0xD4, 0xC3, 0x92, 0x54, 0x89, 0x16, 0xA2, 0x8B,
0x13, 0xF9, 0x0A, 0xBF, 0x20, 0x6A, 0xF7, 0x7B,
0xFE, 0x93, 0x69, 0x9E, 0x95, 0x39, 0x50, 0xC1,
0x4C, 0xFB, 0x98, 0xAE, 0x48, 0x21, 0xA7, 0xA2,
0x8F, 0xBA, 0xB7, 0x35, 0xAE, 0x7F, 0x09, 0x7E,
0x40, 0x54, 0xDE, 0x41, 0xE5, 0xDB, 0x36, 0x0B,
0xBB, 0xA2, 0x0E, 0x60, 0x4E, 0xAD, 0x35, 0x82,
0xBD, 0xD1, 0xDB, 0xA3, 0x84, 0x7D, 0x72, 0xED,
0xA1, 0x06, 0x63, 0x66, 0x32, 0xF6, 0x90, 0x56,
0x6D, 0x0E, 0xE9, 0x76, 0xD7, 0x54, 0xEB, 0x80,
0x20, 0xC8, 0x3E, 0xBB, 0xAF, 0x24, 0x56, 0xAE,
0xBC, 0x93, 0xDD, 0x4D, 0xA1, 0x2B, 0xBA, 0x6F,
0x33, 0x44, 0xF1, 0x8A, 0xDA, 0x1D, 0x18, 0xF5,
0x7F, 0xB6, 0xB3, 0x27, 0x98, 0x22, 0xAC, 0x50,
0xF9, 0x90, 0x6D, 0xB8, 0x91,
0x67, 0xBE, 0x76, 0x28, 0x18, 0xF9, 0x89, 0x63,
0x1C, 0x85, 0xF9, 0x5F, 0x10, 0xFF, 0x4D, 0xF3,
0xCE, 0x0E, 0x4A, 0xC1, 0x31, 0x15, 0x92, 0x72,
0x12, 0x05, 0xFE, 0xD2, 0x5C, 0x42, 0x9B, 0x94,
0x9B, 0xE9, 0xE4, 0x3C, 0x97, 0xC9, 0x18, 0xF6,
0x2A, 0xE7, 0x81, 0x2C, 0xED, 0x55, 0xF7, 0x35,
0xFF, 0xD1, 0x3D, 0x98, 0xED, 0x57, 0x2D, 0x46,
0x5A, 0xA1, 0xAD, 0xFF, 0x4F, 0xBC, 0x80, 0x95,
0x36, 0x3A, 0x87, 0x15, 0xD0, 0x82, 0xDB, 0x12,
0xFC, 0x36, 0x72, 0xA6, 0x33, 0xFB, 0x07, 0x9C,
0xC6, 0x84, 0x04, 0xB8, 0x71, 0x83, 0xD0, 0x9C,
0xAC, 0x1B, 0xB0, 0x27, 0xA9, 0x7D, 0x3D, 0xA3,
0x37, 0x2E, 0x44, 0x1A, 0x7B, 0x2B, 0xF9, 0x4C,
0xED, 0x35, 0xAD, 0x7F, 0xC6, 0x0C, 0xAA, 0xCA,
0xEC, 0xA3, 0x90, 0x7A, 0x26, 0xCD, 0xBF, 0x78,
0x46, 0x57, 0x27, 0x15, 0x06, 0x6F,
0xB8, 0x63, 0x4E, 0xA7, 0xFD, 0x80, 0x9C, 0x1A,
0x18, 0xD5, 0x99, 0x33, 0xFE, 0x67, 0x41, 0x42,
0xE1, 0xD6, 0x3C, 0x9A, 0x3E, 0x9A, 0xCE, 0x47,
0xFF, 0xEA, 0xF2, 0xC6, 0xA9, 0x9F, 0xF3, 0x82,
0x22, 0xAB, 0xB8, 0xE5, 0x42, 0x37, 0xFB, 0xAC,
0xF6, 0x17, 0x5C, 0x08, 0x69, 0x89, 0x61, 0xC7,
0x8B, 0x8E, 0x2E, 0xDA, 0x5B, 0x82, 0xFF, 0x83,
0xFF, 0x1D, 0x53, 0x67, 0xDF, 0x79, 0x52, 0x06,
0xFF, 0xC7, 0x98, 0xBA, 0x9D, 0x6F, 0x73, 0x53,
0x90, 0xF9, 0x40, 0x01, 0x6B, 0xC6, 0x3D, 0x5D,
0xBC, 0x40, 0x35, 0x91, 0x59, 0xDA, 0xDD, 0xC7,
0x61, 0x4E, 0x11, 0x0C, 0x3A, 0x7A, 0xB7, 0x82,
0x38, 0x33, 0xA7, 0x79, 0x78, 0x44, 0x47, 0x7D,
0xB6, 0xF8, 0x71, 0x96, 0x94, 0xBC, 0x8C, 0xAF,
0x81, 0x4E, 0x23, 0xDF, 0x56, 0x75, 0xAF, 0x92,
0x47, 0x2F, 0xF2, 0xF1, 0xE9, 0x9B, 0xA0,
0x20, 0x0D, 0x87, 0x55, 0x4D, 0xA7, 0xD0, 0x0A,
0x17, 0x5D, 0xEC, 0x78, 0x1F, 0x22, 0x99, 0x87,
0x27, 0xD5, 0xA5, 0xD1, 0xE1, 0x67, 0x13, 0xB2,
0x68, 0x84, 0x86, 0x38, 0xBB, 0x2C, 0x2C, 0x57,
0xB3, 0x55, 0x2E, 0x86, 0xE2, 0x27, 0xAE, 0xF4,
0xAF, 0xF5, 0x42, 0x71, 0xE4, 0xC1, 0xC5, 0xAC,
0x64, 0x64, 0xEE, 0xA3, 0x6D, 0x88, 0xAF, 0xD2,
0x6A, 0x8B, 0xC6, 0x19, 0xB6, 0x7A, 0x28, 0x11,
0x96, 0x1C, 0x49, 0xB8, 0x81, 0x29, 0x92, 0x41,
0x7D, 0xB1, 0xB0, 0x6B, 0xC6, 0xB3, 0x71, 0x91,
0x0A, 0x29, 0xE5, 0x10, 0x1F, 0x88, 0xEB, 0xD4,
0x1D, 0x67, 0xB0, 0xB2, 0xF2, 0x20, 0x50, 0xFF,
0x20, 0xB4, 0xCC, 0x3B, 0x32, 0xC0, 0xBC, 0x23,
0x6C, 0x4C, 0x06, 0xC5, 0x09, 0x1C, 0xE4, 0xC2,
0xC9, 0xF6, 0x6B, 0x6D, 0x55, 0xC3, 0x13, 0x76,
0x34, 0x92, 0x83, 0x5A, 0xFA, 0xAE, 0x01, 0xB9,
0x69, 0x97, 0x9D, 0xAC, 0x98, 0x31, 0xD7, 0x1E,
0x55, 0x24, 0x9F, 0x96, 0x5D, 0xF8, 0x58, 0x17,
0xE1, 0x8D, 0x11, 0x06, 0xA2, 0xA5, 0xC6, 0xED,
0x81, 0x4D, 0x91, 0xEE, 0xD5, 0x33, 0x47, 0xCE,
0x52, 0xAF, 0x10, 0x4E, 0xEE, 0x69, 0xDB, 0xD5,
0xE7, 0x93, 0x28, 0x72, 0xAA, 0x60, 0x56, 0xE4,
0x9F, 0x9D, 0x2C, 0xBC, 0xBB, 0xA7, 0x23, 0x11,
0x3A, 0x2F, 0x23, 0x4D, 0x75, 0x24, 0x68, 0xF5,
0x26, 0x1A, 0x28, 0x05, 0xFD, 0x9F, 0x9A, 0x5B,
0x47, 0x74, 0x58, 0x96, 0xAA, 0xD6, 0x7D, 0x65,
0xA2, 0x89, 0xE2, 0x24, 0x98, 0x36, 0x1B, 0xB2,
0xA7, 0x0D, 0xD9, 0xFE, 0xFE, 0xA2, 0x46, 0xFC,
0x33, 0xBC, 0xF4, 0x2E, 0xBF, 0x98, 0x73, 0xEA,
0xFE, 0x2F, 0xBF, 0xF0, 0xFF, 0xD9, 0xEE, 0x10,
0x04, 0x9D, 0x26, 0x6D, 0xCC, 0xA4, 0x97, 0xCD,
0x2A, 0xF9, 0x63, 0x38, 0x15, 0x85, 0x71, 0x91,
0x96,
0xF6, 0x54, 0x0D, 0x68, 0x91, 0x95, 0x59, 0xEE,
0xA5, 0x1A, 0x8C, 0x7F, 0x9E, 0x9E, 0xA4, 0x4F,
0x37, 0xA3, 0x9F, 0x23, 0x01, 0x9E, 0xED, 0x59,
0x34, 0x2E, 0x6D, 0x22, 0x7E, 0x98, 0xBC, 0xE4,
0x22, 0x11, 0xA8, 0xF5, 0xF8, 0xB5, 0xC5, 0x84,
0x11, 0xCA, 0x2A, 0x18, 0xB7, 0x75, 0x9C, 0xB4,
0xC3, 0x29, 0x8B, 0x16, 0x6D, 0x0C, 0x75, 0x34,
0x41, 0x47, 0x70, 0x21, 0x87, 0xD8, 0x1A, 0x3C,
0xFA, 0xCD, 0xEA, 0xD1, 0xC0, 0x20, 0x26, 0xF0,
0xBE, 0x18, 0x51, 0x8F, 0x3E, 0x17, 0xDE, 0x37,
0x2C, 0x67, 0xB5, 0x0A, 0x25, 0xDB, 0x93, 0x1F,
0x9D, 0x27, 0x1F, 0x37, 0xCC, 0xE3, 0xD6, 0x1D,
0xDC, 0xEE, 0xB1, 0x4D, 0x24, 0x75, 0xB8, 0x2E,
0x53, 0x25, 0xBF, 0xF8, 0xFD, 0xBB, 0x7C, 0x72,
0xD0, 0x0E, 0xB7, 0x50, 0xFB, 0xAF, 0xFF, 0x28,
0xBF, 0xD7, 0x93, 0x40, 0x34, 0x40, 0x0C, 0xAB,
0x88, 0x8C,
0x2A, 0x4F, 0x01, 0xAA, 0x2C, 0xF0, 0xAB, 0x86,
0x6D, 0x60, 0xF5, 0x05, 0x5A, 0xD7, 0xB8, 0x3A,
0x2C, 0x7B, 0xB3, 0x55, 0x91, 0x46, 0x2A, 0xA3,
0x17, 0xA8, 0x2E, 0x65, 0xF7, 0x22, 0x1D, 0x44,
0xA7, 0x8D, 0x65, 0x65, 0xD3, 0xAE, 0xFA, 0xE8,
0x3D, 0x7C, 0x0A, 0x8C, 0xCF, 0xEF, 0x5F, 0x25,
0x42, 0x37, 0x3A, 0xCF, 0xD2, 0xC6, 0xEA, 0x30,
0xA9, 0x8F, 0x23, 0x29, 0x28, 0x01, 0xE3, 0x1C,
0xD2, 0x1F, 0xCA, 0xB2, 0x50, 0x4F, 0xBA, 0x8E,
0x83, 0x63, 0x3A, 0x72, 0x58, 0x6C, 0xA5, 0xA5,
0x93, 0x1F, 0xE0, 0x9D, 0xC4, 0x53, 0x0D, 0xE8,
0xC8, 0x20, 0xE5, 0x8E, 0x49, 0x1F, 0x3B, 0x45,
0xFA, 0x46, 0x55, 0x8E, 0x58, 0xBE, 0x43, 0x72,
0x2D, 0xA6, 0x24, 0xC1, 0x6A, 0x5F, 0xCE, 0x88,
0xE0, 0x40, 0x6D, 0xCD, 0x74, 0x0D, 0x66, 0xF3,
0xA0, 0x82, 0x4F, 0x40, 0xD3, 0x7B, 0x3D, 0x50,
0xC5, 0x07, 0xD1,
0x2A, 0x98, 0xF1, 0x6B, 0xF8, 0xDF, 0xE8, 0x5C,
0x7B, 0xD8, 0xE5, 0x50, 0x27, 0x35, 0x02, 0xC8,
0xA6, 0x8D, 0xCE, 0x68, 0xFD, 0x06, 0x0C, 0x10,
0xF3, 0x34, 0x9F, 0x3E, 0xA4, 0xA1, 0x4A, 0x0E,
0xA7, 0x9B, 0xE6, 0x17, 0xBB, 0xBE, 0xD5, 0x37,
0x81, 0xA0, 0xC3, 0xE0, 0xED, 0x11, 0xE8, 0x2C,
0xC7, 0xDD, 0x90, 0xAA, 0x7E, 0xC9, 0x71, 0x36,
0x90, 0xFF, 0x79, 0xFB, 0x8D, 0xC8, 0xFF, 0x5C,
0x9A, 0x64, 0xD2, 0x71, 0xBB, 0xA8, 0x6C, 0x9E,
0x93, 0xFF, 0x77, 0x49, 0x08, 0x2E, 0x3B, 0x5A,
0x91, 0x92, 0xBE, 0xAE, 0xF5, 0x2B, 0xC1, 0x45,
0xF6, 0xFD, 0x81, 0x9D, 0x61, 0xED, 0x05, 0x1F,
0xFE, 0xBF, 0xC3, 0xB1, 0xE5, 0xD9, 0xE3, 0x6C,
0x38, 0xA6, 0x8F, 0xBE, 0x6E, 0x85, 0x1C, 0x32,
0x26, 0xBD, 0x8F, 0xAD, 0xDF, 0xAF, 0xAD, 0x38,
0xA9, 0x22, 0x8A, 0x84, 0xA2, 0x64, 0xA5, 0xB3,
0x66, 0x9C, 0x25, 0x4F,
0x2D, 0x09, 0xE4, 0xB7, 0xAD, 0x96, 0xCB, 0x90,
0x6A, 0x56, 0xCD, 0xEF, 0x1A, 0x04, 0xEB, 0xB4,
0x9C, 0x34, 0x96, 0xF5, 0x5D, 0xFF, 0xDD, 0x8A,
0xC7, 0xFB, 0x21, 0x2F, 0x4E, 0x2F, 0x9D, 0xB4,
0x7F, 0x4C, 0x77, 0x4F, 0x14, 0xA7, 0x79, 0x51,
0x18, 0x55, 0xDD, 0xD1, 0x72, 0xDC, 0x2F, 0xA7,
0x63, 0xA1, 0xF6, 0xE4, 0x98, 0xDE, 0xCD, 0xA5,
0x88, 0xE8, 0x67, 0xCF, 0x10, 0x78, 0xF5, 0x8B,
0x68, 0x78, 0x1D, 0x7E, 0x1A, 0xF3, 0x7C, 0x18,
0x36, 0xFD, 0xA0, 0xDE, 0x17, 0x56, 0xEC, 0xB1,
0xB4, 0xF0, 0xB7, 0x73, 0x90, 0x14, 0xF2, 0xAF,
0x2D, 0xBE, 0xE1, 0xC3, 0xC2, 0x21, 0xDE, 0x4F,
0x35, 0x34, 0xC8, 0x5C, 0x56, 0x9D, 0x5E, 0x29,
0x41, 0x6F, 0x58, 0x50, 0x15, 0x38, 0x0A, 0x1B,
0x50, 0xE8, 0x7D, 0x2F, 0x9F, 0x45, 0xC7, 0x46,
0x39, 0x4F, 0xDF, 0x02, 0x34, 0x0B, 0x45, 0x93,
0x02, 0x2E, 0xEC, 0x14, 0xEF,
0x59, 0xFB, 0x16, 0x58, 0x0F, 0xAF, 0xD0, 0xAD,
0x05, 0x07, 0x9B, 0xBA, 0x45, 0x87, 0x3E, 0x40,
0x6D, 0xAB, 0x90, 0xE8, 0xA2, 0xE5, 0xBD, 0xA5,
0x28, 0x8F, 0xAC, 0xE6, 0xE9, 0xC8, 0x46, 0xA6,
0x84, 0x26, 0x0B, 0x16, 0x65, 0x47, 0x1A, 0x72,
0x52, 0x4C, 0xD3, 0x8A, 0xB1, 0x1F, 0x26, 0x81,
0x8F, 0x23, 0x17, 0x35, 0x4C, 0xCC, 0x72, 0xA3,
0x54, 0x80, 0x09, 0x51, 0x73, 0x3C, 0x49, 0x0F,
0x29, 0x86, 0x23, 0x5F, 0x6C, 0xA5, 0x7A, 0xF7,
0x23, 0x2A, 0x0F, 0x1F, 0x64, 0xA7, 0xBD, 0x36,
0xFB, 0xE6, 0xB7, 0x38, 0xEB, 0x64, 0x2A, 0x45,
0xDD, 0xE7, 0x7C, 0xDC, 0xE7, 0x3F, 0xBD, 0x53,
0xF5, 0xF5, 0x27, 0xAB, 0x89, 0xDF, 0x50, 0x24,
0x51, 0xBA, 0xD8, 0xAC, 0x6D, 0xDD, 0xAC, 0xB3,
0x89, 0x94, 0xE6, 0x26, 0x94, 0x23, 0xFF, 0xF3,
0x2A, 0x11, 0x98, 0xD6, 0x62, 0x11, 0x93, 0x0F,
0x3F, 0xFE, 0x76, 0x94, 0x8D, 0xEA,
0x4D, 0x91, 0x8E, 0xB7, 0x54, 0x12, 0xBC, 0x7C,
0x5C, 0xFF, 0xA6, 0x06, 0x37, 0xE1, 0x37, 0x05,
0x0F, 0xD1, 0x7B, 0xC2, 0x13, 0x3A, 0x59, 0xB3,
0xC4, 0x5C, 0x72, 0x63, 0x47, 0x0D, 0xC5, 0x38,
0x8E, 0xF5, 0x82, 0x2D, 0xBE, 0x74, 0x5E, 0xDF,
0xAD, 0xA5, 0xB0, 0xC9, 0x42, 0x25, 0xE5, 0x7C,
0xA1, 0x9C, 0xCD, 0x49, 0x85, 0xEF, 0x9B, 0xF8,
0x65, 0x8E, 0xEF, 0x9D, 0x5F, 0xE2, 0x2E, 0xC0,
0x57, 0x10, 0x35, 0x0C, 0xFC, 0x35, 0x43, 0x8E,
0x6A, 0xCE, 0x77, 0x8D, 0xF8, 0x0F, 0xC7, 0xD2,
0xE0, 0x8E, 0x4E, 0xFE, 0xBF, 0x27, 0xFD, 0x5A,
0x7E, 0x3F, 0xB9, 0x36, 0x3A, 0x31, 0x0F, 0x47,
0x96, 0x58, 0x63, 0x88, 0x55, 0x14, 0xEC, 0x66,
0xF8, 0x98, 0x03, 0xBE, 0x11, 0x97, 0x83, 0xB1,
0x85, 0xE3, 0x02, 0xF1, 0x7E, 0xA4, 0x45, 0xFC,
0x59, 0x71, 0xB4, 0x99, 0xB8, 0x47, 0x7D, 0x03,
0xAB, 0xB5, 0x65, 0x54, 0x70, 0xDE, 0x1D,
0xA6, 0xD2, 0xCB, 0x79, 0x09, 0x9C, 0xCE, 0xC9,
0xAA, 0x2E, 0x7A, 0x66, 0x79, 0xAE, 0xDD, 0x38,
0xAB, 0x8C, 0x7E, 0xAE, 0x8F, 0x3C, 0x68, 0xA7,
0x59, 0x7A, 0x2C, 0xEA, 0x85, 0x19, 0x58, 0x1B,
0x5F, 0xD3, 0xE7, 0x33, 0x59, 0xB0, 0x2D, 0x60,
0x22, 0x85, 0x08, 0xDF, 0x0B, 0xCB, 0x22, 0x90,
0x48, 0x09, 0xA5, 0x2D, 0x15, 0x5C, 0xA7, 0x8B,
0xBA, 0x6F, 0x49, 0xBE, 0x7D, 0xA1, 0xCB, 0x0B,
0xA4, 0x46, 0xA7, 0xE5, 0x63, 0xEF, 0xB2, 0x32,
0x6C, 0x14, 0x5F, 0x51, 0xA4, 0xC4, 0x85, 0x31,
0xCB, 0xB1, 0x87, 0xE1, 0x6E, 0xB4, 0xEB, 0x51,
0xEA, 0x1B, 0x63, 0x4A, 0x00, 0x3F, 0x2A, 0xFE,
0x1E, 0xCE, 0x59, 0xB5, 0x79, 0xFD, 0x92, 0xD8,
0xF2, 0x7D, 0x20, 0x55, 0x28, 0xA0, 0x91, 0x6E,
0x4A, 0xC9, 0x84, 0x6E, 0x7F, 0x97, 0xEA, 0x42,
0x36, 0xDC, 0x13, 0xB6, 0xD3, 0x2F, 0x11, 0x4B,
0x02, 0x5F, 0xDD, 0x4D, 0xE7, 0xDD, 0xE6, 0x91,
0x68, 0x81, 0xD8, 0xB6, 0x62, 0xE6, 0x17, 0x8A,
0x22, 0xE8, 0x15, 0xD5, 0xA6, 0x2E, 0xAE, 0x08,
0xA6, 0xB9, 0xE1, 0x20, 0x1C, 0x80, 0xDF, 0x54,
0xE2, 0xAE, 0x17, 0x61, 0x4A, 0x54, 0xD2, 0xF8,
0x30, 0x15, 0xE4, 0xF5, 0x5F, 0x7A, 0x18, 0xCF,
0x14, 0x59, 0xED, 0xBA, 0xEF, 0x88, 0x75, 0x87,
0xE9, 0x6C, 0xB8, 0x56, 0x48, 0x51, 0x54, 0x18,
0x31, 0x1F, 0xFD, 0x22, 0x70, 0xD6, 0xAE, 0x59,
0x72, 0x78, 0xF8, 0xE1, 0xA1, 0xC6, 0xD7, 0x7B,
0xE6, 0x2B, 0xE3, 0x05, 0xC8, 0xCF, 0x0D, 0xB2,
0xC8, 0x62, 0x27, 0xD6, 0x32, 0xB0, 0xDF, 0x10,
0x5E, 0x62, 0x97, 0x2D, 0xE3, 0x79, 0x22, 0x51,
0x6D, 0x9A, 0x57, 0x36, 0xBB, 0x63, 0x13, 0x1F,
0x2C, 0xE1, 0xC0, 0x73, 0xA7, 0xFE, 0x64, 0xBC,
0xF6, 0x2F, 0x4D, 0x34, 0x23, 0xDC, 0x0C, 0xF5,
0x02, 0x54, 0xDE, 0x26, 0x62, 0x09, 0xF2, 0xAE,
0xF4, 0xB6, 0x83, 0x46, 0x97, 0xA4, 0x3D, 0xF1,
0x33,
0x23, 0xB6, 0xBC, 0x5C, 0x5F, 0x68, 0x3C, 0xE9,
0x46, 0xF5, 0xD7, 0xD5, 0x1F, 0x84, 0x41, 0x06,
0x66, 0x72, 0xD0, 0x8A, 0xCF, 0xD8, 0x0A, 0xAF,
0x3E, 0x4B, 0x19, 0x09, 0x99, 0x8D, 0x5B, 0x63,
0xE1, 0x01, 0xC0, 0xDC, 0x60, 0x18, 0xE3, 0x32,
0x58, 0xA9, 0xE9, 0x88, 0x0F, 0x7D, 0x4A, 0xE1,
0x15, 0xC8, 0x94, 0x7C, 0x9D, 0x21, 0x13, 0x61,
0xC9, 0xD9, 0x6A, 0x4B, 0x2B, 0x55, 0x22, 0x09,
0x2A, 0x6A, 0xC3, 0xEC, 0x94, 0x5F, 0x5D, 0x1F,
0x4C, 0x47, 0x51, 0xED, 0x16, 0x78, 0x8C, 0x97,
0xEC, 0x50, 0xC8, 0x70, 0x81, 0x5E, 0x9D, 0x4D,
0x26, 0x63, 0x79, 0xCA, 0xC1, 0x0C, 0x3E, 0xFD,
0xE4, 0x9B, 0x85, 0x12, 0x3D, 0xAC, 0xFF, 0x7E,
0x42, 0x0B, 0x31, 0x9B, 0xF3, 0x26, 0x44, 0x0B,
0x2E, 0x3D, 0x13, 0xA3, 0x4E, 0x29, 0xBA, 0x28,
0xCC, 0x65, 0x32, 0x40, 0xAA, 0x61, 0x57, 0x37,
0x89, 0x05, 0x1F, 0x11, 0x72, 0x7B, 0x46, 0x5F,
0x20, 0xDE,
0x01, 0xFB, 0x28, 0x2D, 0xF1, 0x08, 0x02, 0xD4,
0x2C, 0x59, 0xE8, 0x54, 0x97, 0x45, 0xD3, 0xFC,
0xDC, 0x78, 0xA2, 0x86, 0x17, 0x0B, 0x33, 0x2A,
0x12, 0x86, 0x07, 0xCF, 0x00, 0xBC, 0x0B, 0xCE,
0x6A, 0x04, 0x70, 0xF9, 0xC7, 0xC3, 0x02, 0xC3,
0x42, 0xCE, 0x1E, 0xAD, 0x94, 0x80, 0x14, 0xB7,
0xFB, 0xDC, 0x42, 0x7B, 0xDE, 0x5D, 0x67, 0x4D,
0xD8, 0xFD, 0x65, 0x55, 0x02, 0xDA, 0x65, 0x96,
0x84, 0xB0, 0x1F, 0x1D, 0x05, 0x9D, 0x0D, 0xD1,
0x15, 0x30, 0xCF, 0x77, 0x5B, 0xFD, 0xDC, 0xAB,
0x48, 0xFF, 0xBB, 0xE7, 0xB8, 0xD2, 0x33, 0x2E,
0xA2, 0x29, 0x2C, 0x14, 0x0D, 0x33, 0x44, 0xC4,
0xF0, 0xF5, 0x21, 0xA6, 0x10, 0x44, 0xB0, 0x07,
0xB0, 0xBD, 0xE8, 0x88, 0xAB, 0xD1, 0xC1, 0x1F,
0x88, 0x42, 0x6F, 0x05, 0x6F, 0x3B, 0xF9, 0x0D,
0xCC, 0x14, 0x1E, 0x86, 0x19, 0x2B, 0xE8, 0xB2,
0x48, 0x76, 0x10, 0x55, 0x35, 0xBF, 0xCF, 0xAB,
0xCC, 0xAE, 0x78,
0x78, 0xAD, 0x82, 0x7B, 0x78, 0xC7, 0x66, 0x2A,
0xBC, 0x7A, 0xD6, 0xD0, 0x82, 0xE6, 0xF0, 0xC4,
0xC2, 0xF0, 0x1F, 0x1D, 0xE1, 0xE7, 0x9C, 0xCD,
0xAE, 0x32, 0x90, 0xF6, 0x5D, 0xE0, 0xDD, 0x7B,
0x2E, 0x44, 0x64, 0xDE, 0x65, 0xFC, 0x55, 0xB7,
0xC3, 0x4E, 0xB7, 0x86, 0x6A, 0x92, 0x34, 0x2D,
0x4A, 0xBF, 0x40, 0x51, 0x5F, 0x1E, 0xA6, 0x37,
0x47, 0x80, 0x29, 0x2A, 0x86, 0x81, 0x2D, 0xF1,
0x29, 0xE0, 0xA0, 0x5E, 0xC6, 0x41, 0xA5, 0xC6,
0xC2, 0x4E, 0x78, 0x3E, 0x89, 0x42, 0x08, 0x3B,
0x86, 0x2C, 0xD9, 0x8D, 0xAB, 0x18, 0xDB, 0x44,
0xED, 0x64, 0xAD, 0x90, 0x2A, 0x6E, 0x37, 0x17,
0xD2, 0xEB, 0x51, 0xA4, 0x7D, 0xE5, 0xAA, 0x12,
0xCD, 0x24, 0x10, 0xB8, 0xA2, 0x50, 0x90, 0x71,
0xCB, 0xD1, 0xA0, 0x45, 0xAA, 0xBD, 0x21, 0xC7,
0xD6, 0x95, 0xDA, 0x24, 0x38, 0x89, 0x70, 0x98,
0x74, 0x6E, 0x61, 0xF5, 0x92, 0xD4, 0xFA, 0x7D,
0xB5, 0x37, 0xE1, 0x56,
0x1E, 0x72, 0x01, 0x81, 0x4F, 0x98, 0xEC, 0xB2,
0xE1, 0x12, 0xD8, 0x51, 0xB2, 0x10, 0xBD, 0xE9,
0x0A, 0x2C, 0x80, 0x02, 0x63, 0xDD, 0x0C, 0x64,
0xC0, 0xB3, 0x25, 0x99, 0xF3, 0xEC, 0x79, 0x53,
0xB0, 0xC8, 0xC2, 0x6E, 0x19, 0x23, 0x3B, 0x85,
0x5A, 0x2B, 0x32, 0x26, 0x3C, 0xAE, 0xD5, 0x62,
0x62, 0xF2, 0x98, 0x95, 0xFB, 0x77, 0x21, 0x1C,
0xC5, 0xFF, 0x1E, 0xB6, 0x2F, 0x3B, 0x0E, 0x8E,
0x26, 0xD5, 0x4E, 0x5F, 0x7D, 0x4A, 0xCD, 0xE4,
0x1E, 0x32, 0x20, 0x24, 0x3A, 0xDB, 0x71, 0xF4,
0xC9, 0x34, 0x2C, 0x1A, 0x3E, 0xBF, 0xDD, 0x6E,
0x1B, 0x7E, 0x78, 0x7C, 0xF8, 0xD7, 0xB7, 0x7F,
0x65, 0x49, 0x0B, 0xDF, 0x5E, 0x73, 0x6A, 0x2B,
0xB4, 0xC6, 0x30, 0x88, 0x1C, 0x52, 0x5D, 0xB2,
0xBD, 0x83, 0x4F, 0xA7, 0x57, 0x5D, 0x3E, 0x9D,
0xDF, 0x5D, 0x1B, 0x1D, 0x14, 0xB8, 0xFC, 0x0E,
0xEA, 0x32, 0x8C, 0x3C, 0xF4, 0x58, 0x9C, 0x23,
0x22, 0xC5, 0xDD, 0x09, 0x3F,
0x14, 0x36, 0x67, 0xAA, 0xA5, 0x96, 0x16, 0x53,
0xE8, 0x70, 0x94, 0xFB, 0x54, 0x0F, 0x6F, 0x44,
0xAF, 0x4D, 0x57, 0x64, 0x82, 0x9A, 0xDD, 0x60,
0xC3, 0x94, 0x8A, 0xD7, 0x0C, 0xEA, 0xC4, 0xFA,
0x43, 0x93, 0x95, 0xA0, 0x5C, 0x2D, 0x98, 0x89,
0x66, 0xA3, 0x57, 0x4D, 0x22, 0x6B, 0x87, 0x05,
0xE3, 0xB6, 0x8C, 0x55, 0xB5, 0x07, 0x8D, 0x68,
0x8D, 0x28, 0x07, 0x26, 0x30, 0xC5, 0xC3, 0x45,
0x6F, 0x1C, 0x6C, 0xE3, 0xB4, 0x2A, 0x4E, 0xE6,
0x51, 0x18, 0x87, 0x77, 0xD0, 0xDE, 0x98, 0xFD,
0x27, 0xCF, 0xAD, 0xB6, 0x43, 0xAE, 0x07, 0xFD,
0xF8, 0xE8, 0x54, 0x4A, 0xAB, 0xBA, 0x8D, 0x66,
0x4E, 0xF4, 0x03, 0x91, 0x44, 0x07, 0x81, 0x78,
0x98, 0x1D, 0xE4, 0xF8, 0x59, 0xA9, 0x1C, 0x3D,
0xD6, 0x46, 0x37, 0x45, 0x73, 0x26, 0x06, 0xAC,
0x05, 0x7D, 0x98, 0x00, 0xD1, 0x04, 0xEF, 0x1F,
0x71, 0x67, 0x47, 0xF4, 0x32, 0x11, 0x6B, 0x23,
0x8D, 0xDA, 0x88, 0x2A, 0x0C, 0xE2,
0x44, 0xAF, 0x9C, 0x50, 0xA7, 0xEA, 0x78, 0x5B,
0x6F, 0x35, 0xD4, 0xC1, 0x4E, 0xD7, 0x25, 0xF7,
0x82, 0xC1, 0x7F, 0x11, 0xC8, 0xEF, 0x60, 0xC6,
0x60, 0x37, 0x24, 0x67, 0x5E, 0xE3, 0xC9, 0x87,
0x0C, 0x2D, 0x18, 0xB7, 0x25, 0x61, 0xE5, 0x3E,
0xB8, 0xFC, 0xF3, 0x05, 0x4F, 0x7D, 0xD8, 0x85,
0x9A, 0x22, 0x0C, 0xAA, 0xE7, 0x28, 0x5B, 0xD1,
0x0D, 0x8A, 0x46, 0x42, 0x88, 0x90, 0xA7, 0x49,
0xF6, 0x5E, 0x42, 0xC4, 0x74, 0xCE, 0xFB, 0xC5,
0xDF, 0x10, 0xE4, 0xE1, 0x10, 0xBF, 0xD3, 0x25,
0xDB, 0xC4, 0x2F, 0xBA, 0xA7, 0xDB, 0xA0, 0x0B,
0x38, 0x6E, 0x15, 0xCE, 0x6F, 0xB8, 0xEB, 0xF6,
0xB7, 0xDE, 0x85, 0x4E, 0x41, 0x15, 0x1D, 0xA9,
0xE6, 0x5F, 0x8B, 0x81, 0xD7, 0xFD, 0x38, 0xD9,
0xE4, 0x92, 0x29, 0x36, 0xB5, 0x3D, 0x35, 0x14,
0x04, 0xC8, 0x1B, 0xE5, 0x9E, 0x0F, 0x38, 0xF5,
0x0D, 0x85, 0x34, 0x00, 0x6D, 0xA2, 0x9E, 0x84,
0xF6, 0x3C, 0xCA, 0xAE, 0x9B, 0xDC, 0x38,
0x24, 0x65, 0x07, 0x27, 0xB0, 0x37, 0x3D, 0x3C,
0x11, 0xDB, 0x7C, 0x47, 0x78, 0x00, 0x1E, 0xEE,
0x4E, 0xA7, 0x8A, 0x12, 0x57, 0xD9, 0x16, 0x77,
0xA0, 0xCA, 0x4F, 0xD3, 0x5D, 0xC8, 0xDE, 0x95,
0xC5, 0x5A, 0xFD, 0xFF, 0x3F, 0xF1, 0xC0, 0xDA,
0x09, 0x42, 0xC3, 0x4D, 0x9F, 0xBD, 0x23, 0x91,
0xF9, 0x07, 0xD4, 0x7A, 0xB8, 0x44, 0x70, 0xFC,
0xA6, 0x9E, 0xB8, 0x7A, 0x89, 0xF0, 0x75, 0x44,
0xA8, 0x09, 0x2B, 0x2A, 0x0A, 0xB1, 0x26, 0x60,
0x35, 0x11, 0xC6, 0xAB, 0xCB, 0xD1, 0xDB, 0x19,
0x25, 0xCF, 0x60, 0x00, 0x9D, 0x84, 0x07, 0xBF,
0x2F, 0x58, 0x78, 0x17, 0xF9, 0x16, 0xFD, 0x70,
0xFF, 0x5A, 0x70, 0x52, 0xCB, 0xE1, 0x33, 0x73,
0x5B, 0xDA, 0x28, 0x6C, 0x2F, 0xF0, 0x17, 0xC2,
0x52, 0xB5, 0x73, 0x7D, 0x81, 0xE0, 0x7D, 0x34,
0x15, 0x33, 0xF7, 0xCD, 0x6E, 0xF1, 0x0E, 0x9B,
0x60, 0xA6, 0x23, 0x40, 0x5A, 0x3D, 0x06, 0x8C,
0x6A, 0xFC, 0xAD, 0x4C, 0x7F, 0xC7, 0xF4, 0x94,
0x8F, 0xEC, 0x57, 0xDF, 0xC7, 0x2D, 0x22, 0x69,
0xE4, 0x1F, 0xA0, 0xD6, 0xBD, 0xCF, 0x02, 0x3F,
0x31, 0xF2, 0x0E, 0x9E, 0xD5, 0x34, 0x1A, 0xA2,
0x9D, 0xD9, 0x4D, 0xD6, 0x45, 0xB6, 0xF2, 0xD9,
0x17, 0xAA, 0x26, 0x75, 0x30, 0x06, 0x70, 0x16,
0xDC, 0x89, 0x84, 0x3F, 0xB3, 0xD5, 0x2A, 0xDC,
0xB5, 0x4F, 0xA9, 0xC5, 0x49, 0xBE, 0x0F, 0xDC,
0xA2, 0x91, 0xB9, 0x41, 0x31, 0xBC, 0x56, 0x96,
0x74, 0x48, 0xF0, 0xAF, 0xA8, 0x4F, 0x3C, 0x25,
0xAF, 0x3E, 0xEF, 0x33, 0x33, 0x18, 0xDF, 0xE3,
0x64, 0xA2, 0xCD, 0xA0, 0x29, 0xF8, 0x31, 0x68,
0xC4, 0x34, 0x78, 0x1A, 0x3A, 0x4D, 0x83, 0xB8,
0x4A, 0xF2, 0xE2, 0x4E, 0xA8, 0x72, 0x78, 0x7C,
0xAB, 0x7A, 0xC7, 0xBB, 0x81, 0xCE, 0x30, 0xBD,
0x05, 0x8E, 0xB9, 0x6B, 0xC0, 0x1A, 0xFD, 0x22,
0x56, 0x4C, 0x12, 0x28, 0x76, 0x28, 0x44, 0xF4,
0x37, 0xFE, 0xAC, 0x2D, 0x0D, 0x2E, 0x78, 0x9A,
0x8E, 0x93, 0xC8, 0xB9, 0x1E, 0xA3, 0x9C, 0x4A,
0x09,
0xA0, 0x36, 0x27, 0x9A, 0xE3, 0x90, 0x3F, 0x1D,
0xAE, 0xD1, 0x4E, 0xB4, 0x5B, 0x6B, 0x2E, 0x02,
0x6B, 0x27, 0x22, 0x14, 0x8D, 0x16, 0xFC, 0xA6,
0xDC, 0xFA, 0xB9, 0xDD, 0xD5, 0xAA, 0x13, 0x8E,
0xD4, 0x23, 0xB4, 0x30, 0x4B, 0x55, 0x0E, 0x03,
0x37, 0xB4, 0x25, 0x35, 0xBC, 0x45, 0x65, 0xAE,
0xBF, 0xE9, 0x23, 0xC3, 0x56, 0x8C, 0xE9, 0xEE,
0x4E, 0x82, 0x8A, 0xD8, 0xDF, 0x93, 0xA2, 0x75,
0x13, 0xB8, 0x00, 0x83, 0xF2, 0x80, 0x53, 0x48,
0xDF, 0x95, 0xBB, 0xF3, 0x3D, 0xCF, 0x67, 0xEA,
0x10, 0x20, 0xAA, 0xF5, 0xD7, 0xF3, 0x94, 0x58,
0x3F, 0x59, 0x03, 0x5B, 0x82, 0x83, 0x90, 0x07,
0x46, 0x59, 0xDC, 0x58, 0x3D, 0x4F, 0x91, 0xBE,
0x13, 0x35, 0xC9, 0x1B, 0x2B, 0x26, 0x9F, 0x87,
0x8F, 0x2F, 0xA9, 0xB9, 0xD7, 0x5A, 0x68, 0xB2,
0xB3, 0xA8, 0x5C, 0x8E, 0x46, 0x0B, 0xE3, 0x2B,
0x33, 0x0A, 0xC5, 0xB9, 0xDA, 0x4B, 0xAB, 0xCC,
0xD3, 0x18, 0xC9, 0xB1, 0x4B, 0x7C, 0x0A, 0x3E,
0x66, 0xC0,
0x01, 0x41, 0xBD, 0x80, 0xE8, 0x7A, 0x5B, 0x4D,
0xCB, 0x33, 0xE1, 0x26, 0x0C, 0x44, 0x02, 0x92,
0x56, 0x81, 0x95, 0x35, 0x32, 0xE6, 0x87, 0xDD,
0x18, 0x48, 0x17, 0x68, 0xBC, 0xD9, 0x79, 0x88,
0xE4, 0xD9, 0xF8, 0xF1, 0xE5, 0x74, 0x2E, 0xFD,
0x37, 0xD8, 0xA3, 0x17, 0x93, 0xBB, 0xA9, 0xD4,
0x34, 0xDC, 0xCB, 0xCB, 0x70, 0xA7, 0xEA, 0x48,
0x8A, 0x54, 0x22, 0xDB, 0x1E, 0xED, 0xBE, 0x1A,
0x0B, 0x68, 0x45, 0xED, 0x61, 0xA9, 0x95, 0x5C,
0x96, 0x6C, 0x8E, 0x30, 0x5E, 0xE2, 0xD1, 0xEB,
0xB1, 0xAE, 0xE7, 0x01, 0x64, 0x36, 0x1C, 0xC8,
0x75, 0xDD, 0x52, 0xB6, 0x90, 0x1D, 0x25, 0xA3,
0x91, 0x5E, 0x48, 0xF7, 0xED, 0xD1, 0x70, 0x10,
0x6A, 0x75, 0xDF, 0x76, 0x98, 0x7F, 0xC2, 0xAE,
0xF4, 0xAC, 0x34, 0x29, 0x7B, 0xA8, 0xF7, 0x04,
0x0F, 0xFE, 0x08, 0xB9, 0x82, 0x81, 0x6C, 0x4E,
0x95, 0x14, 0xD2, 0xE7, 0x74, 0x05, 0xA2, 0x71,
0x86, 0x62, 0xBF, 0x6B, 0x44, 0xC5, 0x28, 0x7F,
0x92, 0xBD, 0xEC,
0xF5, 0x8C, 0x9B, 0x44, 0x49, 0x96, 0xBA, 0x9D,
0x97, 0x45, 0x94, 0xFF, 0x3B, 0xA6, 0x77, 0x8F,
0xB5, 0x0D, 0xAF, 0x8C, 0xD2, 0x97, 0x4E, 0xAA,
0x2F, 0xD0, 0x2B, 0xE9, 0xBA, 0x0E, 0xAE, 0xDB,
0xFE, 0x83, 0x37, 0xA9, 0xEA, 0x82, 0xF8, 0x05,
0x8B, 0x8E, 0xBC, 0x8A, 0xF0, 0xBC, 0x6D, 0xFD,
0xA9, 0x1C, 0x31, 0x36, 0x3D, 0x1F, 0xFB, 0x99,
0x96, 0x6A, 0x0A, 0x36, 0x99, 0xE7, 0xD5, 0xA8,
0xFF, 0x14, 0x8A, 0x1B, 0xC0, 0xCB, 0x94, 0x74,
0x74, 0x89, 0x2F, 0xF9, 0x2E, 0x47, 0x2A, 0x4B,
0x4B, 0x13, 0x13, 0x76, 0x4B, 0xF8, 0x1B, 0x61,
0x5B, 0xD2, 0x4A, 0xC4, 0xF3, 0x23, 0x8C, 0xFB,
0x19, 0x32, 0x3F, 0x41, 0xCC, 0x50, 0x8E, 0x07,
0x81, 0x4F, 0x00, 0x5E, 0xF6, 0x23, 0xC1, 0x41,
0x83, 0xB0, 0xFB, 0xE2, 0xBB, 0x57, 0xB1, 0xF0,
0x82, 0x7F, 0x8B, 0x9C, 0x3D, 0xAB, 0x30, 0xB8,
0x31, 0x88, 0xFA, 0x8E, 0xD9, 0x90, 0x55, 0x8B,
0x5F, 0xC9, 0x06, 0xF0, 0x06, 0xBB, 0x4F, 0x2D,
0x43, 0x96, 0x7E, 0x47,
0xED, 0x17, 0xCD, 0x7E, 0x1C, 0xB3, 0x1B, 0xE1,
0x21, 0x0D, 0x3C, 0xA6, 0x99, 0x00, 0xE6, 0x1E,
0x77, 0xC6, 0xE1, 0x5E, 0x2B, 0x16, 0xA5, 0x64,
0xC0, 0xEE, 0x64, 0x7C, 0xC2, 0x24, 0x16, 0x03,
0x10, 0x95, 0x1C, 0x21, 0x82, 0x77, 0xAB, 0xB8,
0x0E, 0x30, 0xF5, 0x8F, 0x8B, 0x9B, 0x64, 0xD4,
0x53, 0xA1, 0xD7, 0x90, 0xC8, 0x85, 0x81, 0xE6,
0x88, 0x6F, 0x53, 0x42, 0x74, 0x61, 0xCE, 0xCA,
0x66, 0xDC, 0x28, 0x3E, 0x6D, 0x8D, 0xEB, 0xF8,
0x8A, 0xB8, 0x18, 0x4C, 0x65, 0x01, 0xA4, 0xAF,
0x91, 0x46, 0xBD, 0xD7, 0xF3, 0xCC, 0x00, 0xEA,
0x2B, 0x75, 0x7A, 0x7F, 0x9B, 0x07, 0x26, 0x4A,
0x3A, 0x72, 0xB0, 0xF7, 0x03, 0x0D, 0x31, 0xCD,
0xBF, 0x7E, 0xEC, 0x34, 0x1A, 0x66, 0x18, 0x0E,
0x4A, 0x63, 0xEB, 0x02, 0x6E, 0x9C, 0x93, 0xAA,
0x24, 0x49, 0x47, 0xAF, 0xEA, 0x7A, 0x18, 0x5A,
0x26, 0x08, 0x97, 0x31, 0x7D, 0xED, 0x12, 0x9B,
0x6A, 0x01, 0xE3, 0xFF, 0x2F, 0x5F, 0x63, 0x59,
0xC2, 0xE8, 0x03, 0x17, 0xF9,
0x60, 0x98, 0x3E, 0x4F, 0xF9, 0x28, 0xBB, 0x55,
0xFD, 0x8F, 0xD1, 0xD6, 0x3F, 0xD7, 0x2A, 0x48,
0x77, 0x31, 0x59, 0xD6, 0xA8, 0x76, 0x54, 0x48,
0xE8, 0xB4, 0x48, 0x4E, 0x01, 0x92, 0xC8, 0xB5,
0x33, 0x3A, 0x1E, 0x4E, 0x0A, 0x7D, 0x55, 0x7E,
0xC0, 0x77, 0xB0, 0x6C, 0x29, 0xB2, 0xBF, 0xB8,
0x1A, 0xCC, 0x6F, 0x52, 0xE9, 0x80, 0x2C, 0x6C,
0xBF, 0x74, 0x71, 0xDE, 0xC5, 0x60, 0x17, 0x8F,
0x13, 0xC3, 0xBA, 0xE2, 0x08, 0xDA, 0x1F, 0xDC,
0x71, 0x5D, 0xC6, 0xF5, 0xB3, 0xA1, 0xBA, 0x6E,
0x05, 0x22, 0x34, 0x35, 0x35, 0x5F, 0x96, 0x9A,
0xDF, 0x9C, 0xD0, 0x97, 0xCB, 0xBF, 0x93, 0x84,
0x9A, 0xF5, 0x2F, 0xEE, 0x94, 0x4B, 0x37, 0x73,
0x23, 0xA7, 0x91, 0xF6, 0x2D, 0x07, 0x54, 0xCB,
0x53, 0xC4, 0x52, 0xAD, 0xAE, 0xA3, 0xE4, 0x53,
0x00, 0xEB, 0x11, 0x84, 0x7D, 0x40, 0xC6, 0x86,
0xEC, 0x2D, 0xCB, 0x03, 0xCD, 0x8B, 0xCF, 0xFC,
0xB1, 0xBD, 0xEE, 0x93, 0xB3, 0xB2, 0x0C, 0x4F,
0xF5, 0x08, 0xAD, 0x4B, 0xBD, 0x85,
0xD9, 0xD0, 0x9C, 0x36, 0xA0, 0x0A, 0xFA, 0xAB,
0x82, 0xB1, 0x7C, 0xD6, 0x21, 0xF3, 0x0A, 0xC5,
0x4B, 0x33, 0xA3, 0xEB, 0xD9, 0xC5, 0xDA, 0x49,
0xF8, 0xF1, 0x03, 0x4F, 0xE3, 0xCD, 0x88, 0x1A,
0xFF, 0x76, 0xD9, 0xBE, 0x7F, 0xB6, 0xA0, 0x6E,
0x4A, 0xB4, 0xDA, 0xA5, 0x89, 0xDB, 0x81, 0x8F,
0xDA, 0x99, 0x5C, 0x77, 0xCE, 0x08, 0x6E, 0xB3,
0x44, 0x4F, 0x85, 0xEF, 0xFA, 0xD6, 0xE3, 0x1B,
0x01, 0xD0, 0xAF, 0xB8, 0xF7, 0x23, 0xF5, 0x90,
0x77, 0xBA, 0xB4, 0x69, 0xB1, 0xA3, 0x45, 0x89,
0xEE, 0xB8, 0xCF, 0xEA, 0x66, 0x38, 0x95, 0xB7,
0xBA, 0xC5, 0x7C, 0x1D, 0x63, 0x43, 0x63, 0x14,
0x90, 0xA1, 0x46, 0x31, 0x79, 0x07, 0x82, 0x58,
0x09, 0x04, 0xED, 0xD7, 0x71, 0x74, 0x64, 0x8A,
0xB5, 0x66, 0x60, 0x1F, 0x8B, 0x7A, 0x03, 0x13,
0xA7, 0x4D, 0xC8, 0x88, 0x1B, 0xCF, 0x20, 0x61,
0x86, 0xD0, 0x96, 0x51, 0x20, 0x82, 0x27, 0x3B,
0x44, 0xFE, 0x95, 0xEA, 0x04, 0xD4, 0xF7, 0x27,
0x5C, 0xB4, 0x89, 0x54, 0x2F, 0x16, 0x2B,
0x36, 0x2E, 0x57, 0x62, 0x22, 0x2E, 0xA2, 0xA0,
0x88, 0xEC, 0xC3, 0x9E, 0x96, 0x4C, 0xAA, 0x43,
0x4D, 0xF1, 0x0A, 0x1E, 0x1B, 0xCE, 0x5C, 0x51,
0xF5, 0xF5, 0x16, 0x1D, 0x77, 0x82, 0xE2, 0xDD,
0x71, 0x20, 0x83, 0xC2, 0x7C, 0x80, 0xCE, 0x06,
0xAF, 0xEB, 0xAF, 0x06, 0xE3, 0xD7, 0x3A, 0x8D,
0x03, 0xD8, 0x6A, 0x18, 0x71, 0x3B, 0xBA, 0x81,
0x23, 0x8C, 0x1A, 0xB2, 0x29, 0x68, 0x93, 0xE9,
0xC2, 0x84, 0x89, 0x9C, 0x10, 0xAE, 0x27, 0xB2,
0x8A, 0xC6, 0xF9, 0x5B, 0x2B, 0x02, 0x20, 0x2B,
0x0D, 0xBE, 0x37, 0xF3, 0x94, 0x2C, 0x4B, 0xF3,
0x45, 0x55, 0xAF, 0x99, 0x16, 0x84, 0xB1, 0x6B,
0x2E, 0xA7, 0xEC, 0x8D, 0x2B, 0x5A, 0x95, 0x28,
0x91, 0xFE, 0x7B, 0x7B, 0xB0, 0x6B, 0xA3, 0x00,
0xB6, 0x15, 0x1B, 0x1D, 0x68, 0x91, 0x79, 0xAC,
0x48, 0xA6, 0xF9, 0x6A, 0x3D, 0x8D, 0x67, 0x73,
0x49, 0x09, 0x43, 0xD5, 0x96, 0xA3, 0x07, 0xC9,
0x94, 0x33, 0x3A, 0xA4, 0xDA, 0xA5, 0x91, 0x88,
0xF7, 0x1F, 0x60, 0x87, 0xBF, 0xC5, 0x18, 0x08,
0xA4, 0xDF, 0xDE, 0xA3, 0x07, 0x88, 0x14, 0x98,
0xC0, 0xEE, 0xED, 0xD3, 0xEB, 0xFE, 0x27, 0xB5,
0xD3, 0x60, 0x14, 0x33, 0x32, 0xF6, 0x90, 0x97,
0xF2, 0x89, 0xE0, 0xD4, 0x11, 0xD5, 0x19, 0x57,
0x19, 0x0C, 0x7F, 0xED, 0xD2, 0xD5, 0xB4, 0x3A,
0xB8, 0xE7, 0xE7, 0x24, 0xF7, 0xA8, 0x8C, 0x44,
0x8E, 0xDF, 0x1C, 0x1E, 0x03, 0xE1, 0x58, 0x56,
0x2F, 0xE7, 0x01, 0xBD, 0x9C, 0x8C, 0x40, 0x3D,
0x96, 0x43, 0xB5, 0x26, 0x6A, 0x10, 0xB9, 0x25,
0x83, 0x50, 0xD1, 0x78, 0xF1, 0xF7, 0x4B, 0x59,
0xF4, 0xAF, 0xBB, 0xCA, 0xA7, 0xC3, 0xE9, 0x3C,
0x2D, 0x8E, 0xB5, 0xB5, 0x4A, 0xC0, 0xF3, 0x1C,
0x80, 0xFC, 0xBF, 0xD0, 0x78, 0x98, 0x29, 0x0F,
0x5E, 0x0A, 0x2A, 0x5C, 0xC6, 0x4C, 0x1C, 0x29,
0xEF, 0xCA, 0xE4, 0xBB, 0x11, 0xA6, 0xCA, 0x68,
0x8C, 0xB8, 0xB8, 0x6E, 0x28, 0x4C, 0x1A, 0xF3,
0xA4, 0x33, 0xBC, 0x8B, 0x4D, 0xD9, 0xF9, 0x17,
0xDD, 0xE3, 0x90, 0x90, 0xCC, 0x5E, 0x77, 0x3F,
0xCC, 0xF4, 0x86, 0xC4, 0x9C, 0xBD, 0x72, 0x9E,
0x12,
0x85, 0x5E, 0xB9, 0x55, 0xFA, 0xCC, 0xAF, 0xC8,
0xB3, 0x75, 0xC6, 0x63, 0x9D, 0xEA, 0x0F, 0xC6,
0xF5, 0xBF, 0x0E, 0xA3, 0xB7, 0x8E, 0xE5, 0x7F,
0x65, 0xA6, 0x91, 0x22, 0x1B, 0x35, 0xD8, 0xE4,
0x82, 0x95, 0xC6, 0xA3, 0x9C, 0x4B, 0x93, 0x00,
0x4F, 0x1C, 0x66, 0x4A, 0x9D, 0x91, 0x3B, 0x05,
0x84, 0x5E, 0x46, 0x30, 0x5F, 0x4F, 0x99, 0xF9,
0xCB, 0x88, 0xE6, 0x5C, 0xEF, 0x5D, 0xEB, 0x2F,
0x71, 0x57, 0x53, 0xC1, 0x2E, 0xC4, 0xB3, 0x18,
0x9B, 0x9F, 0x5D, 0x9D, 0xF0, 0xCE, 0xEE, 0xA0,
0x2A, 0x3E, 0x71, 0x36, 0x13, 0x68, 0x03, 0x60,
0x24, 0x8B, 0xD3, 0x0D, 0x40, 0x41, 0x75, 0x1C,
0x45, 0xFE, 0x18, 0x88, 0xFE, 0xA9, 0x39, 0x5A,
0xD8, 0xA0, 0xF7, 0x04, 0xA1, 0xF3, 0xB5, 0xAA,
0xD1, 0x48, 0x3A, 0x1F, 0x5A, 0xA2, 0xE5, 0x30,
0x94, 0x5C, 0xDC, 0xA4, 0x9E, 0xE9, 0x42, 0xB0,
0x55, 0xAC, 0xE5, 0x34, 0xB6, 0x5E, 0x8A, 0x6E,
0x32, 0x76, 0xE1, 0x4F, 0xC9, 0xFC, 0xB7, 0xD8,
0x39, 0x0F, 0xA7, 0xBF, 0x57, 0x8A, 0x63, 0x63,
0xE5, 0x77,
0xC1, 0xE0, 0x92, 0xC5, 0xD9, 0x31, 0x46, 0x05,
0x34, 0xC5, 0x22, 0x1C, 0x5F, 0x9D, 0x12, 0x00,
0x49, 0x80, 0x8E, 0xBA, 0x48, 0x4A, 0xFD, 0x06,
0x4E, 0xD0, 0xEB, 0xC5, 0x54, 0xD4, 0x74, 0x48,
0x83, 0x6D, 0x4A, 0x78, 0x45, 0x97, 0xA9, 0xE8,
0x32, 0x1A, 0x16, 0x85, 0xCF, 0xEA, 0xE5, 0x40,
0x51, 0x05, 0x10, 0x76, 0x51, 0xFD, 0x9D, 0x0D,
0x18, 0xBF, 0x49, 0xA6, 0xAF, 0x3A, 0xBA, 0xDE,
0x8E, 0x37, 0xAB, 0x18, 0x5E, 0x03, 0x84, 0x3C,
0x43, 0x35, 0x51, 0x73, 0x66, 0xF7, 0xC1, 0x2F,
0xEE, 0x61, 0xCF, 0x5F, 0xD7, 0x88, 0x6C, 0x85,
0x3D, 0xE6, 0x2E, 0x70, 0x8D, 0x7D, 0x85, 0xC2,
0x9D, 0x80, 0xB8, 0xB9, 0xCA, 0x6B, 0x0A, 0x4B,
0x7F, 0x65, 0x90, 0xF3, 0x66, 0xC4, 0x2B, 0x8D,
0x2D, 0xAE, 0x32, 0xCA, 0x75, 0x48, 0x18, 0x06,
0x7E, 0x34, 0xB1, 0xB1, 0xDC, 0x94, 0xD2, 0xCE,
0x77, 0x81, 0xDD, 0x41, 0x39, 0x72, 0xC6, 0x01,
0x6C, 0xCD, 0xE4, 0xF8, 0x20, 0xEC, 0x61, 0x22,
0x14, 0x77, 0x79, 0xB0, 0x50, 0xAE, 0x15, 0x32,
0x1C, 0x99, 0xCE,
0xF0, 0x4E, 0xC9, 0xD5, 0x02, 0xC3, 0x86, 0xBF,
0x4D, 0x98, 0x4F, 0x0B, 0xCE, 0x3D, 0xFC, 0x18,
0x8B, 0xB5, 0x52, 0x76, 0xBC, 0x85, 0x5C, 0x83,
0xD4, 0x88, 0xBA, 0x16, 0xA1, 0x72, 0x9A, 0x00,
0x79, 0xED, 0x55, 0xF0, 0x95, 0x8C, 0x2B, 0x44,
0x7B, 0xCE, 0x74, 0xB8, 0x2D, 0x31, 0x96, 0xC3,
0x48, 0x70, 0x0E, 0xF1, 0x8F, 0xD1, 0x93, 0xDE,
0x77, 0xFE, 0x3F, 0x2E, 0xDC, 0x99, 0xD9, 0xC7,
0xA9, 0x23, 0x68, 0xF8, 0x1F, 0xDA, 0x5B, 0x55,
0x88, 0x7B, 0x9B, 0x45, 0xFB, 0x87, 0x55, 0x0F,
0x1F, 0x54, 0x21, 0xF2, 0xE6, 0x33, 0xF6, 0x5F,
0x4F, 0x2A, 0x3D, 0xAD, 0xA1, 0x24, 0x62, 0x98,
0x63, 0x0D, 0xBB, 0x59, 0x56, 0xEB, 0x64, 0x7F,
0x88, 0xFC, 0x2F, 0x88, 0x6F, 0x44, 0x5B, 0x1E,
0xE7, 0xBD, 0x10, 0xCB, 0x6D, 0xF3, 0xAB, 0x15,
0x3E, 0x64, 0x7A, 0x42, 0xBD, 0xFF, 0xD7, 0x51,
0xA4, 0x0D, 0x58, 0xDD, 0x8B, 0x23, 0xB4, 0xD9,
0xB0, 0x8E, 0x84, 0xB6, 0x09, 0x09, 0x93, 0x3F,
0xB0, 0x97, 0x18, 0xA4, 0x06, 0x90, 0xE8, 0xED,
0xCE, 0x9F, 0x15, 0xF9,
0x61, 0x25, 0xD1, 0xE5, 0x89, 0xDD, 0x70, 0xC0,
0xD1, 0xE4, 0xEB, 0x15, 0xFF, 0x20, 0x8B, 0xA8,
0x2F, 0xD8, 0x85, 0x53, 0x39, 0x7A, 0xDA, 0x20,
0x5A, 0x29, 0x17, 0xFA, 0x5A, 0x2B, 0x01, 0x8C,
0x07, 0x51, 0x68, 0x38, 0xD6, 0xA3, 0x0C, 0x03,
0x4C, 0xBE, 0x2A, 0xFB, 0x05, 0x7F, 0x21, 0x9F,
0x30, 0x57, 0x13, 0x32, 0x36, 0xEA, 0xF6, 0xE0,
0x46, 0xC0, 0x60, 0x1F, 0xE4, 0xCA, 0x9B, 0x5E,
0x55, 0x68, 0xFC, 0xDD, 0x80, 0xD4, 0x2A, 0xFB,
0x05, 0xAB, 0x0D, 0xF0, 0xA9, 0xC0, 0x77, 0x4B,
0x73, 0x5F, 0x35, 0x86, 0xC7, 0x78, 0xBB, 0xAB,
0xD3, 0x5E, 0x86, 0x41, 0x76, 0x7B, 0xFA, 0x47,
0x82, 0x90, 0x0F, 0x57, 0x67, 0x74, 0x88, 0xB0,
0x28, 0xBD, 0x47, 0xFB, 0x02, 0xA1, 0x6E, 0xD4,
0xBA, 0xEB, 0x2D, 0xF5, 0xD6, 0x0C, 0x2D, 0xE3,
0x01, 0x8A, 0xDD, 0x08, 0x6C, 0xFD, 0x0C, 0x1A,
0x53, 0xF0, 0xDF, 0x92, 0x8C, 0xEE, 0x6E, 0x65,
0x97, 0x6F, 0x65, 0x1D, 0x87, 0xB7, 0xE9, 0xA5,
0x9A, 0x77, 0x28, 0x6E, 0x94, 0x74, 0x75, 0xC3,
0xA6, 0xD6, 0x7E, 0xD2, 0x56,
0x87, 0x13, 0xD2, 0x36, 0x32, 0x7F, 0x8F, 0x49,
0x0C, 0x49, 0x15, 0xD7, 0x8F, 0x01, 0x6B, 0x31,
0x49, 0x08, 0x80, 0xBC, 0x14, 0x15, 0x99, 0x1A,
0x1F, 0x8C, 0x06, 0x22, 0x25, 0x35, 0x64, 0x0D,
0x7D, 0xC5, 0x7A, 0x84, 0xE2, 0x2F, 0x35, 0x2F,
0x6F, 0x18, 0xBB, 0xD1, 0x33, 0x8D, 0x27, 0xA5,
0x57, 0xA7, 0x5F, 0x12, 0x0E, 0xA0, 0x04, 0xFB,
0x4D, 0x70, 0xF3, 0x23, 0x7F, 0x7F, 0xC0, 0xF6,
0x47, 0xD0, 0xAE, 0x33, 0xC5, 0x67, 0x0A, 0xFC,
0x1B, 0x78, 0x35, 0x36, 0xE2, 0x06, 0x7E, 0x1E,
0x4B, 0xFA, 0xB5, 0x52, 0x83, 0xE7, 0x70, 0x88,
0xB0, 0x23, 0xEA, 0x6B, 0xD5, 0x90, 0xAE, 0x10,
0x03, 0x7E, 0x24, 0xE9, 0xC2, 0x07, 0xE0, 0xEF,
0xE8, 0xE0, 0x49, 0x25, 0x4F, 0xB9, 0x30, 0xDD,
0x5B, 0x13, 0x7C, 0x2B, 0xA1, 0xC4, 0x1A, 0x11,
0xF6, 0xA4, 0x96, 0xDB, 0xF5, 0x15, 0xD6, 0x1C,
0xC6, 0xBE, 0xF6, 0xAD, 0x85, 0x60, 0xB6, 0xE8,
0x5F, 0xE4, 0xE3, 0xA4, 0x7A, 0x90, 0xD9, 0xE9,
0x01, 0xBA, 0x65, 0x81, 0x67, 0x14, 0x38, 0x05,
0x9C, 0x66, 0xF2, 0x46, 0xB2, 0xBD,
0xB5, 0xEB, 0x44, 0x98, 0x9A, 0x21, 0x63, 0x60,
0x47, 0x81, 0x6D, 0x74, 0x25, 0xE7, 0x7D, 0x13,
0x9A, 0x06, 0x17, 0x0E, 0xCA, 0x11, 0xA6, 0x99,
0x52, 0x01, 0xCE, 0x4D, 0xBD, 0x6B, 0xBD, 0x88,
0xC1, 0x32, 0xE9, 0x4E, 0x30, 0xFB, 0xB4, 0x1C,
0x97, 0xBA, 0x10, 0xE8, 0xBD, 0xD7, 0xE4, 0x94,
0xE1, 0x0B, 0x67, 0xD3, 0x3B, 0xC1, 0x2F, 0x60,
0xBD, 0xE1, 0xE4, 0xB2, 0x64, 0x5F, 0xF3, 0x47,
0xB2, 0xD5, 0x63, 0x4A, 0x50, 0x14, 0xEB, 0x43,
0x65, 0xD6, 0x2A, 0x0D, 0xF0, 0x28, 0xD2, 0x63,
0xC5, 0x68, 0x50, 0xEE, 0x6D, 0x6F, 0xCF, 0x8E,
0x8B, 0x86, 0x5A, 0x1C, 0xBA, 0x60, 0xE7, 0x97,
0x11, 0x71, 0x43, 0x5D, 0xA6, 0x0B, 0x49, 0x16,
0xB9, 0x0D, 0x69, 0x6E, 0x8B, 0xF2, 0xAC, 0x70,
0xAA, 0xF6, 0xE8, 0xCB, 0x69, 0xFA, 0xAF, 0xF7,
0x34, 0x33, 0x0B, 0xD9, 0xF4, 0xFD, 0x19, 0x18,
0x05, 0x11, 0x41, 0x53, 0x2B, 0x83, 0x2A, 0xC7,
0xA7, 0xA3, 0x02, 0x4A, 0xB8, 0x43, 0x5B, 0x5C,
0x43, 0xD3, 0x97, 0x95, 0x03, 0xBE, 0xF1, 0x44,
0x28, 0x6C, 0x35, 0x0C, 0x75, 0x76, 0xCD,
0x4A, 0x52, 0x37, 0xDC, 0x4B, 0x83, 0x60, 0xFF,
0x29, 0x04, 0xA5, 0xD2, 0x34, 0xBC, 0x42, 0xC6,
0xDB, 0x39, 0x18, 0xE8, 0x3D, 0x15, 0x88, 0x0E,
0x7C, 0x88, 0x82, 0xD5, 0x97, 0x93, 0x02, 0xA0,
0x9C, 0x44, 0x06, 0x35, 0x5A, 0x26, 0x99, 0x8D,
0x5C, 0x99, 0x3C, 0xC0, 0x75, 0x45, 0xE0, 0xFC,
0xFA, 0x65, 0x00, 0x23, 0x6D, 0xB8, 0xC7, 0xA2,
0x48, 0x91, 0x86, 0xF4, 0xBD, 0xC2, 0x82, 0xFF,
0x11, 0x2A, 0x53, 0xED, 0x81, 0xD5, 0xB0, 0x4A,
0x94, 0x7F, 0x34, 0x64, 0xC6, 0xB8, 0x54, 0x9A,
0xED, 0x3E, 0xC1, 0x1D, 0x97, 0x71, 0xED, 0x2A,
0xDA, 0x24, 0x62, 0x57, 0xE2, 0xAF, 0xD3, 0x9C,
0xFD, 0x85, 0x5E, 0xCC, 0xDC, 0x31, 0x5A, 0x6C,
0x49, 0x01, 0xA9, 0x37, 0x98, 0x78, 0x1D, 0x82,
0x13, 0x28, 0x5C, 0xDB, 0x56, 0x0C, 0x44, 0xB3,
0xA1, 0x96, 0x77, 0x03, 0xCB, 0x13, 0x0A, 0x75,
0xBD, 0x6B, 0x8F, 0x37, 0x7B, 0x97, 0xC6, 0xEF,
0x0B, 0x67, 0x0A, 0x66, 0xCF, 0xE7, 0x23, 0x47,
0x9A, 0x20, 0x41, 0xB3, 0xC9, 0xEA, 0x69, 0x1B,
0x4A, 0x06, 0x4E, 0x8D, 0x3C, 0x21, 0x91, 0xA8,
0xE3, 0x4D, 0x9E, 0x76, 0x52, 0xFB, 0xAD, 0xBD,
0xC9, 0x68, 0x80, 0x14, 0x72, 0xD7, 0x20, 0xF0,
0x22, 0xD0, 0x6E, 0x95, 0x15, 0x1D, 0x19, 0x9B,
0xE4, 0x80, 0xA1, 0xC5, 0x4C, 0xF3, 0x09, 0x28,
0xED, 0x69, 0xBE, 0x50, 0xDC, 0x4A, 0x88, 0xE8,
0x6E, 0x8C, 0x23, 0x1B, 0x5F, 0xF8, 0xE9, 0xDD,
0x38, 0x60, 0x95, 0x2E, 0x9C, 0x2C, 0xED, 0x1B,
0x3D, 0x68, 0x3A, 0x64, 0x1E, 0x28, 0x8A, 0x19,
0xB0, 0x9D, 0xC0, 0xB6, 0xF1, 0x9F, 0x5E, 0x9F,
0x40, 0x0C, 0x10, 0x64, 0x48, 0x5A, 0x5B, 0xCA,
0x4C, 0x17, 0xB7, 0x4A, 0x19, 0x43, 0x4E, 0x66,
0x21, 0x33, 0xF3, 0x96, 0x9C, 0xC0, 0x9A, 0xD8,
0xB9, 0x7F, 0xAC, 0x6A, 0x8C, 0xDB, 0x9E, 0xDC,
0xEF, 0x4E, 0xA0, 0xB1, 0x0A, 0x85, 0xDD, 0xAA,
0xF8, 0x41, 0xD2, 0xDF, 0x4F, 0x09, 0x19, 0x48,
0x44, 0xC9, 0xD3, 0xF2, 0xAC, 0x55, 0x89, 0xF1,
0x3F, 0x38, 0x55, 0x40, 0xBF, 0x6E, 0x40, 0x8C,
0x32, 0x0C, 0x24, 0xF5, 0x53, 0xBB, 0x26, 0x89,
0xC5, 0x84, 0x76, 0x68, 0xD0, 0xAF, 0x71, 0xD1,
0xDF, 0xB0, 0x67, 0x9B, 0x68, 0xEB, 0x8C, 0xE6,
0x19,
0xFE, 0x25, 0xE1, 0x5B, 0xBB, 0xBD, 0x35, 0x9F,
0xD6, 0xA0, 0x77, 0x26, 0x28, 0x73, 0xA5, 0x44,
0x95, 0x6C, 0x23, 0xB9, 0x51, 0xBA, 0x45, 0x7A,
0xA9, 0x61, 0x7F, 0x48, 0x0B, 0x78, 0xBD, 0x6F,
0xC2, 0x42, 0x43, 0x5A, 0x25, 0x80, 0xE6, 0x03,
0xC4, 0xEB, 0x26, 0x05, 0xA4, 0xB5, 0x87, 0x5D,
0xF3, 0xC8, 0x6A, 0xD5, 0x60, 0x71, 0xBC, 0x7A,
0xD8, 0x85, 0x13, 0x4A, 0x8B, 0x44, 0xA9, 0xC4,
0x24, 0x29, 0xB2, 0x97, 0x49, 0x79, 0xE3, 0x64,
0x3E, 0x6E, 0x5F, 0xA6, 0xF3, 0xF4, 0xDF, 0x8F,
0x25, 0x03, 0x7E, 0xE2, 0xFA, 0xBE, 0xA3, 0xFF,
0x35, 0x2A, 0x8C, 0xE0, 0xA9, 0x74, 0x11, 0xC6,
0x44, 0x0B, 0x17, 0xC4, 0x15, 0xCC, 0x08, 0xEE,
0xF2, 0xC9, 0x0E, 0xEA, 0x00, 0xC0, 0xD6, 0xAD,
0xC8, 0x21, 0xD8, 0xCB, 0x86, 0x69, 0xF6, 0x7E,
0x26, 0x7F, 0x4B, 0xDB, 0x91, 0x7C, 0xA6, 0x89,
0x07, 0x1A, 0x71, 0xAC, 0x0F, 0x81, 0x6B, 0x8E,
0x99, 0x10, 0xB0, 0x99, 0x1B, 0x88, 0x6F, 0xF2,
0x7A, 0xB7, 0xA0, 0xC4, 0x76, 0x2B, 0xC4, 0x8E,
0x9F, 0xAE, 0xA5, 0xB6, 0x10, 0x4A, 0x01, 0xCA,
0xB7, 0x3A,
0x76, 0x01, 0x63, 0xA9, 0xFB, 0xDB, 0xD9, 0x5E,
0x9F, 0x9B, 0x1E, 0xC6, 0x8E, 0x78, 0xDB, 0x44,
0xF4, 0x61, 0xE5, 0x0C, 0x1E, 0x6C, 0xD4, 0xCC,
0xBD, 0x27, 0x0A, 0xE5, 0xB4, 0x53, 0x86, 0x05,
0xDD, 0xE0, 0x49, 0x24, 0x88, 0x1E, 0xEC, 0x5A,
0x09, 0x1B, 0xA3, 0x4A, 0xBE, 0xFD, 0x6C, 0xC6,
0x6A, 0x57, 0xFE, 0x8C, 0x79, 0xC5, 0x63, 0x7F,
0x11, 0x3A, 0x7C, 0x3F, 0x01, 0xCF, 0x14, 0x69,
0x44, 0xFA, 0xCB, 0xE4, 0x93, 0xDD, 0x4F, 0xF3,
0x8A, 0x9C, 0x73, 0xD9, 0x6E, 0xA0, 0xD3, 0xF0,
0x6E, 0x3E, 0x92, 0x58, 0x2D, 0xB4, 0x0F, 0xD5,
0x4B, 0x15, 0xEE, 0x7F, 0x54, 0x39, 0x86, 0xA3,
0x08, 0x47, 0x2B, 0xF3, 0xB8, 0x55, 0xC6, 0x92,
0xF1, 0x2B, 0x5C, 0x1F, 0x9B, 0x3B, 0x6B, 0x9F,
0x3E, 0x16, 0x35, 0x8D, 0xE4, 0x42, 0xEC, 0xF0,
0xEB, 0x2B, 0x2E, 0x78, 0x4E, 0x54, 0x49, 0x3E,
0x7E, 0x20, 0xAD, 0x41, 0x61, 0xEC, 0x07, 0x8A,
0x38, 0x3F, 0x8B, 0x7F, 0x4C, 0x92, 0x84, 0x54,
0x56, 0x2D, 0x0E, 0x53, 0xCB, 0x7C, 0x43, 0xE9,
0xE6, 0x29, 0xE6, 0x29, 0x6A, 0x78, 0x3F, 0x35,
0x7C, 0xB3, 0xE3,
0x1A, 0x09, 0xE5, 0x28, 0xDB, 0xFA, 0x7A, 0x05,
0x08, 0xC3, 0x34, 0xB3, 0x44, 0xCB, 0x74, 0x8D,
0x86, 0xFF, 0x68, 0x4A, 0xDD, 0x8C, 0x9C, 0x63,
0x7A, 0xF8, 0xE4, 0x2D, 0xDA, 0x3E, 0xBA, 0x02,
0x6E, 0xA8, 0x2D, 0x33, 0xDA, 0x82, 0x8F, 0xA0,
0x0E, 0x5F, 0xBA, 0x76, 0xF0, 0x51, 0xB7, 0xCE,
0xAE, 0x55, 0xE1, 0x55, 0x13, 0xB6, 0xF1, 0x19,
0xA9, 0xEE, 0x5D, 0x44, 0x7A, 0x97, 0xBD, 0xE0,
0x68, 0x98, 0x34, 0xC8, 0x15, 0xDC, 0xD5, 0x47,
0xFD, 0x1E, 0x10, 0x05, 0xCF, 0x02, 0x29, 0x90,
0x65, 0x67, 0xCA, 0x32, 0xE6, 0xFC, 0xC3, 0x44,
0x83, 0xC4, 0xC2, 0x56, 0xBC, 0x82, 0x72, 0x4A,
0x5F, 0x3E, 0x1C, 0x20, 0xB4, 0xB6, 0x40, 0xCA,
0x63, 0x3A, 0x35, 0xDC, 0x64, 0xE8, 0x84, 0x69,
0x25, 0x35, 0x6E, 0xEA, 0xB3, 0x90, 0x7A, 0xC7,
0xA9, 0xF6, 0x77, 0x6A, 0x2D, 0xDF, 0x9B, 0xD3,
0x21, 0xC0, 0xD9, 0x24, 0x1A, 0x02, 0xE4, 0x5A,
0xF9, 0xDA, 0xD9, 0x4A, 0x7F, 0xE0, 0xFF, 0x4B,
0xD5, 0xA3, 0x5B, 0xBE, 0xE0, 0xA5, 0x20, 0xB9,
0x70, 0x32, 0x29, 0x21, 0x2C, 0x66, 0x91, 0x6E,
0x4D, 0x49, 0x77, 0x46,
0xBA, 0x59, 0x2F, 0x5B, 0xD9, 0x94, 0x89, 0x97,
0x47, 0x3C, 0x2F, 0xB1, 0x1B, 0xC8, 0x0E, 0x76,
0xF0, 0xE7, 0x1F, 0xA0, 0x98, 0xA5, 0x91, 0xEA,
0x0B, 0x2F, 0x7A, 0x9E, 0x85, 0xEC, 0x5B, 0x5F,
0xA2, 0x4B, 0xF1, 0xCD, 0xD8, 0x9F, 0x4D, 0xC4,
0xDB, 0xEB, 0x16, 0xF1, 0x88, 0x30, 0x64, 0x83,
0xA2, 0x0A, 0xA9, 0x1C, 0x78, 0xF4, 0x9B, 0x7B,
0x90, 0x79, 0x8B, 0x2E, 0x80, 0x20, 0xC3, 0x9F,
0xBC, 0xFB, 0x6E, 0x7D, 0x32, 0x8E, 0xF0, 0x3F,
0x79, 0xD7, 0x04, 0xB0, 0xF8, 0xFD, 0xD6, 0xF8,
0xC3, 0x46, 0xC8, 0x6B, 0xDD, 0x8B, 0x6B, 0x63,
0xED, 0xB7, 0xCE, 0xCB, 0xDF, 0x4F, 0x1C, 0x28,
0x6C, 0x47, 0x90, 0x88, 0x97, 0x5B, 0x02, 0x7E,
0xA3, 0xAA, 0x17, 0xE5, 0xB6, 0x6C, 0x4D, 0x42,
0x69, 0xEF, 0x1D, 0x99, 0x0A, 0x40, 0x77, 0x4F,
0xED, 0x36, 0x60, 0xA2, 0xB2, 0x77, 0x59, 0xA6,
0xCE, 0xFE, 0x33, 0xF2, 0xED, 0x41, 0xF9, 0x93,
0x18, 0xC9, 0x32, 0x6A, 0xAA, 0x86, 0xC2, 0x7C,
0xF3, 0xF1, 0x01, 0x9F, 0x5E, 0x2D, 0x65, 0x23,
0x3E, 0x14, 0x08, 0xE9, 0xFB, 0xC6, 0x24, 0x10,
0x10, 0x7F, 0x25, 0x5F, 0x14,
0x67, 0x70, 0xB2, 0x88, 0x41, 0xC4, 0x8B, 0x36,
0xFA, 0x5E, 0x79, 0x02, 0x9D, 0x98, 0x00, 0x66,
0x1D, 0x8D, 0x54, 0x74, 0xFD, 0x2C, 0x7C, 0x23,
0x7C, 0x05, 0xA4, 0x59, 0x7E, 0x13, 0x5A, 0x10,
0x9C, 0xF7, 0xD4, 0x12, 0x73, 0x57, 0x4A, 0xDF,
0x8A, 0x3C, 0x3F, 0x35, 0x53, 0xC7, 0x9A, 0x13,
0x98, 0x4D, 0xB5, 0x88, 0x45, 0x13, 0x93, 0x27,
0xF3, 0xBA, 0xD9, 0x8C, 0xB9, 0xCB, 0x0A, 0x5C,
0xC5, 0xB0, 0xC2, 0x34, 0x50, 0xD5, 0x26, 0x75,
0xEB, 0xFB, 0x44, 0x3C, 0x31, 0x66, 0x8A, 0xBB,
0xCE, 0xF3, 0x83, 0xCE, 0x01, 0xBB, 0x53, 0xD0,
0x8D, 0x48, 0x3B, 0x21, 0xF3, 0x5C, 0x76, 0x92,
0xCE, 0x3F, 0x42, 0xF0, 0xCC, 0x79, 0xE4, 0x8E,
0x11, 0x54, 0xE3, 0x52, 0xED, 0xE9, 0x7E, 0x2B,
0x18, 0x11, 0x14, 0x67, 0x46, 0x75, 0x4A, 0x9C,
0xF8, 0x43, 0xD8, 0xFA, 0x3C, 0xE7, 0xDC, 0xD3,
0xCD, 0x01, 0x33, 0xA9, 0x99, 0x79, 0x44, 0x70,
0x67, 0x15, 0x75, 0xB2, 0x87, 0x96, 0x63, 0x75,
0x02, 0x8E, 0xA2, 0x0A, 0x37, 0x39, 0x8C, 0x9A,
0xB7, 0xEE, 0x9D, 0xC8, 0xB9, 0xA0, 0xFE, 0xBE,
0x1A, 0x7E, 0x0A, 0xC1, 0x86, 0xE4,
0x5E, 0x02, 0xEA, 0x3C, 0x14, 0x99, 0x54, 0x6F,
0x10, 0x11, 0x70, 0x05, 0x70, 0x5C, 0x5C, 0xD7,
0xD6, 0x1B, 0xCA, 0x05, 0x29, 0xA1, 0xA3, 0x00,
0x5D, 0xAC, 0x56, 0xFF, 0xC1, 0x09, 0x8B, 0x70,
0x7D, 0x7F, 0x49, 0x92, 0xC3, 0x75, 0x07, 0xCF,
0x36, 0x1A, 0xF0, 0x5B, 0xB5, 0xAE, 0xDB, 0xCC,
0x2E, 0x8A, 0xCC, 0x46, 0x1F, 0xAE, 0x09, 0x74,
0x40, 0x2F, 0x3B, 0xC1, 0x7B, 0x51, 0x08, 0x1F,
0x7C, 0xBB, 0x95, 0x9E, 0x70, 0x42, 0x30, 0xEB,
0x7B, 0xDE, 0xC7, 0xA2, 0x71, 0x44, 0x06, 0x4A,
0x77, 0x97, 0xD1, 0x3C, 0xFD, 0xFB, 0x2E, 0x06,
0x9C, 0x0E, 0xAD, 0xFE, 0x29, 0x53, 0xFB, 0xAE,
0x92, 0x18, 0x4F, 0xB0, 0xF5, 0xCD, 0xDC, 0xDF,
0x4E, 0x3C, 0x82, 0xBC, 0x4A, 0x62, 0x84, 0x8E,
0x7E, 0x63, 0x6E, 0x1F, 0x2D, 0xDC, 0x09, 0x5F,
0xDE, 0x76, 0x03, 0x81, 0x32, 0xD5, 0x9E, 0x88,
0xE6, 0xED, 0x2A, 0x58, 0xFC, 0x58, 0x1D, 0xCF,
0xA6, 0x89, 0xF1, 0x76, 0x19, 0xCA, 0xDB, 0x6E,
0xEB, 0xE8, 0x82, 0x73, 0x3D, 0x48, 0x69, 0xF6,
0x18, 0xF0, 0xBD, 0xEA, 0xA2, 0xF2, 0x23, 0xF7,
0x58, 0x58, 0x15, 0x7C, 0x79, 0x1B, 0x61,
0xD6, 0x80, 0x97, 0x69, 0xEF, 0x00, 0x1A, 0x83,
0xCA, 0xDB, 0x59, 0x1B, 0x5A, 0xC9, 0x7E, 0x42,
0x3C, 0xD5, 0x72, 0x10, 0x67, 0x26, 0xAE, 0x79,
0x40, 0x0D, 0xC4, 0xB2, 0x57, 0x93, 0x7A, 0x21,
0xEA, 0x56, 0x38, 0x67, 0xF2, 0x2D, 0xA6, 0xBE,
0xEA, 0xAE, 0xF9, 0x1E, 0xCD, 0xCA, 0xE7, 0x32,
0xCE, 0x3D, 0x5C, 0x09, 0x3E, 0x84, 0x4E, 0xD4,
0x68, 0xC0, 0x05, 0x2F, 0x95, 0x15, 0xD5, 0xBB,
0xF8, 0x65, 0x92, 0x5E, 0x39, 0x10, 0xB0, 0x4E,
0x7C, 0x0A, 0xF8, 0x6E, 0xCE, 0xD0, 0x74, 0xE0,
0x63, 0xC9, 0xC3, 0x1D, 0x46, 0x6A, 0x76, 0x24,
0x11, 0x47, 0x23, 0xB2, 0x1E, 0xCE, 0x33, 0xB0,
0xF0, 0xD1, 0x9A, 0x76, 0x3C, 0xC1, 0xD9, 0x62,
0x01, 0xBB, 0x88, 0x65, 0xBE, 0xA6, 0x2D, 0xDD,
0xB4, 0x14, 0x87, 0x9F, 0xB5, 0x90, 0xC7, 0x6F,
0xAF, 0x9D, 0x4A, 0x5C, 0x4D, 0xA7, 0x5B, 0xAE,
0x42, 0x5A, 0xC1, 0x15, 0x7D, 0xE7, 0xA9, 0x72,
0x08, 0x4E, 0xE6, 0xF6, 0xC7, 0xAE, 0x1F, 0x21,
0xAA, 0xE5, 0x8F, 0x7A, 0xFD, 0x1D, 0x3A, 0xCF,
0x78, 0xF3, 0x29, 0xDD, 0xE6, 0xF1, 0x8C, 0xDD,
0xCD, 0x66, 0x20, 0x91, 0x5D, 0xFE, 0xC1, 0xA8,
0xFE, 0x6B, 0x1F, 0x77, 0x4E, 0x7B, 0x71, 0x34,
0x8E, 0x3B, 0x5A, 0xBE, 0x1D, 0x14, 0x88, 0xF7,
0xB3, 0xF0, 0x60, 0x02, 0xFA, 0x1C, 0x87, 0x78,
0xD4, 0x3C, 0x1E, 0x68, 0x82, 0xB7, 0xA5, 0xC8,
0x63, 0xA2, 0xD2, 0x07, 0x21, 0x4C, 0xA3, 0x42,
0x97, 0xC1, 0xFE, 0x75, 0xDE, 0xC5, 0x73, 0x25,
0xA1, 0x1E, 0xAD, 0x22, 0x89, 0xD2, 0xD8, 0xED,
0x11, 0x0F, 0x4B, 0x56, 0xFB, 0xDF, 0x7B, 0x8A,
0x9F, 0xF9, 0xE2, 0xC8, 0xC2, 0x13, 0x8F, 0x35,
0x49, 0x40, 0x4B, 0x56, 0xB5, 0xA4, 0x12, 0xFA,
0xC7, 0x0E, 0xA2, 0x0A, 0xF9, 0x25, 0xCC, 0x67,
0x95, 0x96, 0xC9, 0x51, 0x6F, 0xA5, 0x43, 0xED,
0x82, 0xB4, 0xA5, 0x0E, 0xE0, 0x28, 0xAD, 0xF7,
0x4A, 0x4B, 0x1B, 0x83, 0x84, 0x9A, 0x21, 0xF5,
0x4B, 0xCC, 0xCA, 0x1F, 0x03, 0xF5, 0xD3, 0xBB,
0x42, 0xA7, 0x5C, 0x1E, 0xDE, 0xD3, 0xC0, 0x77,
0x21, 0xDB, 0xCC, 0x56, 0x08, 0xAF, 0x1A, 0xE3,
0x03, 0xE0, 0x89, 0x52, 0x51, 0x0E, 0x46, 0xA6,
0xBE, 0x38, 0x39, 0xC1, 0xF6, 0xB1, 0x84, 0xD4,
0xD8, 0xE5, 0xC1, 0x60, 0xA9, 0x3C, 0x04, 0xD1,
0xCE, 0x31, 0x9D, 0xBA, 0x64, 0xFC, 0xCD, 0x39,
0x31,
0x90, 0x2D, 0x76, 0x65, 0x81, 0x31, 0xEA, 0x2E,
0xF1, 0x55, 0xED, 0x9B, 0xB8, 0xC7, 0x5E, 0x87,
0xD8, 0x1A, 0xBB, 0xF8, 0x84, 0xB2, 0x0A, 0xFB,
0x5F, 0xB9, 0x2E, 0x9B, 0xA7, 0xFE, 0x31, 0xFA,
0xE7, 0xF4, 0xFA, 0x25, 0x0B, 0xAA, 0xCE, 0xCF,
0x33, 0x9C, 0xF6, 0x16, 0x9C, 0x60, 0x1F, 0xC9,
0xA1, 0x6E, 0xF1, 0x3B, 0xFC, 0x85, 0xE3, 0x15,
0xC9, 0xD0, 0x4E, 0xF0, 0x8D, 0xF7, 0xE4, 0x87,
0x74, 0x6D, 0xCF, 0x3E, 0xBE, 0x15, 0x1D, 0xFE,
0x26, 0xE6, 0x3E, 0x44, 0xF9, 0xA5, 0x01, 0xB1,
0xAF, 0x4A, 0x39, 0x00, 0x2C, 0xCE, 0x87, 0x58,
0xE0, 0xDE, 0x18, 0x75, 0xF5, 0x6D, 0xE9, 0xDE,
0xC7, 0xDA, 0x3D, 0xBE, 0x01, 0xFD, 0x31, 0xE9,
0x61, 0xCE, 0x80, 0xB4, 0xE5, 0x49, 0x5D, 0x46,
0xDB, 0x5A, 0xCC, 0x4F, 0x21, 0xEE, 0xF9, 0x72,
0x81, 0x67, 0x76, 0xAB, 0xEE, 0x65, 0x89, 0x74,
0x78, 0x57, 0x5A, 0x1A, 0x4B, 0x4F, 0x98, 0xCA,
0x9E, 0xEF, 0x55, 0xDB, 0xBA, 0xEE, 0xF6, 0xA6,
0xB0, 0xFC, 0x34, 0xBA, 0x1E, 0xE9, 0x66, 0x28,
0xDA, 0x61, 0xFA, 0x67, 0x8E, 0x68, 0x38, 0xFE,
0xE0, 0x29, 0xC4, 0xB3, 0x22, 0x33, 0xF6, 0x0C,
0x07, 0xCA,
0xEB, 0x62, 0xBD, 0xEB, 0xBF, 0x64, 0xA1, 0xCE,
0x44, 0x90, 0xF4, 0x8A, 0x99, 0x3E, 0x27, 0x18,
0x61, 0x44, 0x2B, 0xBC, 0xB7, 0xA9, 0x44, 0x3F,
0x26, 0x9A, 0x41, 0x9E, 0x4E, 0x91, 0xDE, 0x3B,
0x10, 0xAD, 0x10, 0x83, 0x61, 0x5B, 0x51, 0x14,
0xF9, 0xAD, 0x61, 0x0C, 0xA2, 0x1B, 0x70, 0x56,
0x11, 0x9C, 0x7F, 0xBE, 0x45, 0x03, 0xA8, 0xF2,
0xDB, 0x3B, 0xB9, 0x0B, 0xB5, 0x8F, 0xB2, 0x8D,
0x53, 0xE4, 0x0B, 0xAA, 0xAD, 0xCD, 0x0A, 0xB1,
0x18, 0x3B, 0x51, 0xF7, 0x90, 0x3D, 0x95, 0x62,
0xBD, 0x87, 0x4C, 0x7E, 0x5E, 0x58, 0x53, 0xB4,
0xE5, 0x43, 0x5A, 0x4F, 0x01, 0x24, 0xE2, 0xD3,
0x12, 0x4F, 0xA1, 0xAD, 0x0A, 0x3E, 0xF3, 0x2A,
0x45, 0x26, 0x6C, 0x80, 0xA7, 0xEE, 0x22, 0xEB,
0x3A, 0xA1, 0xD4, 0x5F, 0x0B, 0xBE, 0x7B, 0xC4,
0x2D, 0x6A, 0xB5, 0xF8, 0xFF, 0x6C, 0x93, 0x29,
0x15, 0x98, 0x82, 0x7B, 0x69, 0x58, 0xFF, 0x2E,
0x00, 0x9D, 0x20, 0x42, 0xDC, 0x71, 0xBC, 0x73,
0x26, 0x3A, 0x5F, 0x3C, 0x86, 0xD8, 0xF7, 0xD9,
0xA3, 0x29, 0x72, 0x60, 0x8B, 0x7C, 0x64, 0xD4,
0x00, 0xA0, 0x1C, 0x45, 0x6B, 0x19, 0x12, 0x3B,
0x8E, 0xAF, 0x02,
0xB7, 0x1F, 0x1D, 0xCD, 0x68, 0x41, 0x99, 0x17,
0x85, 0xAA, 0x47, 0x02, 0x5D, 0x37, 0x88, 0x21,
0xA3, 0x56, 0x06, 0x71, 0x22, 0x89, 0xB3, 0xAB,
0x8E, 0x59, 0x17, 0x05, 0x55, 0x1D, 0xC8, 0x31,
0x30, 0xA2, 0xF5, 0x1E, 0x36, 0xD8, 0x7D, 0x52,
0xF0, 0x59, 0x6F, 0xF7, 0xA1, 0xC3, 0x3D, 0x84,
0xF4, 0x57, 0x05, 0x2B, 0xEF, 0x6A, 0x8F, 0xD7,
0x57, 0xF4, 0xA2, 0x4C, 0xB2, 0x11, 0xD8, 0xD0,
0xB1, 0x31, 0x2D, 0x2C, 0x56, 0x3F, 0xA8, 0x99,
0x95, 0x52, 0xE9, 0xDC, 0xF7, 0x78, 0xCC, 0xE8,
0x69, 0xDD, 0xCD, 0xE7, 0xC6, 0x53, 0xEA, 0xDE,
0x8B, 0x52, 0xBF, 0x3B, 0x84, 0x77, 0xAC, 0x34,
0x56, 0xE0, 0x0A, 0xD6, 0x60, 0x52, 0x96, 0xD7,
0x91, 0x0D, 0xAE, 0x06, 0xA1, 0x27, 0xB4, 0xD1,
0xF6, 0x8C, 0x15, 0xF8, 0x63, 0x04, 0x0B, 0xA8,
0x0A, 0xD7, 0x7E, 0x8F, 0x11, 0x04, 0x61, 0x79,
0x5C, 0x1B, 0x52, 0x5F, 0xFE, 0xC5, 0x83, 0xF9,
0x82, 0x72, 0x65, 0x9F, 0x01, 0x41, 0x8D, 0x1E,
0xEF, 0xB5, 0x5D, 0xD1, 0xEE, 0x78, 0x54, 0x97,
0xB5, 0xD0, 0xC7, 0x15, 0x10, 0x87, 0x82, 0xDE,
0xDA, 0x18, 0xA7, 0x75, 0xF4, 0xAA, 0x4D, 0xFF,
0x95, 0x4B, 0xB3, 0x11,
0xB0, 0x5B, 0xC5, 0x7F, 0x06, 0xF8, 0xFC, 0x82,
0x8F, 0x68, 0xC3, 0xAD, 0xB3, 0x85, 0xE1, 0xFF,
0x0A, 0x66, 0x88, 0x57, 0xB2, 0x9E, 0x75, 0x4A,
0x52, 0x04, 0x1C, 0x42, 0x27, 0xEA, 0x04, 0xFA,
0xF2, 0x32, 0xBF, 0x5D, 0x55, 0xA5, 0x10, 0x2C,
0x75, 0xDF, 0xD1, 0x38, 0x35, 0xCF, 0x6F, 0xE9,
0xFA, 0x1D, 0xEE, 0x9D, 0xC7, 0xAC, 0xD4, 0x1B,
0x5F, 0x42, 0x93, 0x11, 0x90, 0xBB, 0x81, 0x60,
0xE2, 0x12, 0x18, 0x0C, 0x96, 0x77, 0xBF, 0xA4,
0x89, 0xBD, 0x6C, 0x20, 0x8D, 0x35, 0xB3, 0xE2,
0x86, 0x3B, 0xE8, 0x88, 0x1D, 0xD6, 0x28, 0x72,
0x96, 0x29, 0x97, 0x7F, 0xC6, 0xB7, 0x12, 0x94,
0x81, 0x6B, 0x4E, 0x7E, 0x4C, 0x51, 0x5F, 0x33,
0xB1, 0xD8, 0x57, 0x37, 0xE9, 0xA2, 0x6C, 0x98,
0x81, 0x38, 0x3F, 0xCF, 0x38, 0x2A, 0x28, 0xF5,
0xB6, 0xF7, 0x4D, 0x3C, 0x58, 0x9C, 0x2B, 0xE8,
0xE9, 0x0F, 0xFF, 0x66, 0x53, 0xC3, 0x81, 0x28,
0xB3, 0xA5, 0x00, 0x0A, 0x41, 0x95, 0x82, 0xFA,
0x84, 0x82, 0x1B, 0xC5, 0x0F, 0x43, 0x3E, 0xD6,
0xBC, 0x2B, 0x9A, 0xDE, 0x85, 0x6E, 0x69, 0xC4,
0xD7, 0xAD, 0xF6, 0xA5, 0x7B, 0xFE, 0xC2, 0x13,
0xA2, 0xD9, 0xC7, 0xBE, 0x2B,
0xC8, 0x2C, 0x78, 0x3B, 0x2A, 0x2F, 0x34, 0x42,
0x4E, 0x77, 0x85, 0x1F, 0xA8, 0xC4, 0xE8, 0x6A,
0x6D, 0x4C, 0x95, 0x30, 0xBA, 0xFC, 0x29, 0x86,
0x8B, 0x29, 0x99, 0x06, 0x82, 0xD9, 0x98, 0xCB,
0x0C, 0x08, 0xA5, 0x78, 0xC8, 0xE0, 0x1C, 0x37,
0xB5, 0x8C, 0x99, 0x20, 0x1A, 0xC5, 0xBD, 0x1B,
0xAF, 0x64, 0x99, 0xD6, 0xE0, 0xE2, 0xF8, 0xAA,
0xB4, 0xAF, 0x30, 0xF1, 0xDC, 0x59, 0xA7, 0xB1,
0xB4, 0x15, 0x16, 0x90, 0xFD, 0x31, 0x59, 0xF2,
0xE5, 0xF2, 0xA1, 0x7C, 0x16, 0x8F, 0x70, 0x4C,
0xE2, 0x5D, 0x6C, 0xB6, 0xEE, 0x96, 0x66, 0x63,
0xEE, 0x34, 0x20, 0x86, 0x48, 0x30, 0x77, 0xA3,
0xDA, 0x77, 0xDF, 0x94, 0x96, 0xBF, 0xD2, 0x69,
0x9E, 0x09, 0x73, 0x7B, 0xA9, 0xDB, 0x6D, 0x47,
0xB2, 0xAD, 0x58, 0x3B, 0x68, 0xA7, 0x29, 0x69,
0x58, 0x05, 0x36, 0x61, 0x40, 0x44, 0x11, 0x83,
0x0E, 0xD6, 0xD7, 0xD9, 0x48, 0xE2, 0x59, 0x47,
0xA2, 0xF8, 0xE0, 0x4B, 0xE5, 0x1E, 0xFD, 0xDA,
0xD7, 0x23, 0x78, 0xF4, 0x4A, 0xF8, 0x85, 0x47,
0x5E, 0xE5, 0x03, 0x2C, 0x57, 0x3A, 0x4E, 0xA6,
0x78, 0xC6, 0x59, 0xA1, 0x92, 0xFA, 0xF1, 0xC2,
0x2E, 0x96, 0xCF, 0x97, 0x18, 0xB5,
0x46, 0xE9, 0x7C, 0xAA, 0xD8, 0x7C, 0x19, 0x28,
0xF9, 0x5C, 0xE2, 0x43, 0x06, 0x85, 0x5B, 0x18,
0xE0, 0x7C, 0x99, 0x1B, 0xD3, 0xF9, 0xDA, 0x2C,
0xE2, 0x6F, 0x7E, 0xF1, 0x35, 0x4E, 0x2E, 0x32,
0xCD, 0xB9, 0xAA, 0xFC, 0xBF, 0x7D, 0xF8, 0xCA,
0xAC, 0xEA, 0x5D, 0x5A, 0x1D, 0xDB, 0x8B, 0xD1,
0xD4, 0xD1, 0xC6, 0xBB, 0x1C, 0x9D, 0xF4, 0x0B,
0x97, 0xEA, 0xB8, 0x36, 0x68, 0x9A, 0x06, 0xFE,
0xD1, 0xC3, 0xAB, 0x68, 0x8A, 0xDD, 0xB2, 0xC3,
0x0D, 0xAC, 0x6B, 0x15, 0x2B, 0x53, 0x5E, 0xB2,
0xFF, 0x90, 0x49, 0x37, 0x7A, 0xD9, 0xB4, 0x3C,
0xCC, 0xB7, 0xB8, 0x11, 0x8B, 0xCE, 0xB3, 0x42,
0x3B, 0xAA, 0x63, 0x7E, 0x67, 0xC1, 0x4F, 0x72,
0x94, 0xDB, 0xC0, 0x64, 0x70, 0xDA, 0x8B, 0x63,
0x29, 0x37, 0x94, 0x96, 0xB7, 0x0F, 0x89, 0x6A,
0x11, 0x22, 0x2D, 0xF9, 0x03, 0x87, 0x6B, 0xDC,
0x81, 0xE1, 0x8A, 0x19, 0xD4, 0xC8, 0xDA, 0x59,
0xAE, 0x0C, 0x60, 0x94, 0xFF, 0x2F, 0xD0, 0xC9,
0xD3, 0x76, 0x29, 0x38, 0x72, 0xAA, 0x29, 0x79,
0xB2, 0xF3, 0xC4, 0x06, 0x68, 0xD8, 0x8C, 0x3D,
0xD0, 0x41, 0x82, 0xA6, 0x03, 0x1F, 0xF1, 0x8B,
0x8A, 0x9B, 0xF1, 0xAD, 0x23, 0xC2, 0x49,
0x6F, 0x32, 0x87, 0x55, 0xB2, 0xCF, 0xF0, 0xBE,
0x33, 0xC5, 0x18, 0x77, 0x2E, 0x9B, 0x0F, 0x98,
0x2A, 0x6F, 0xAF, 0x8D, 0x9F, 0x7F, 0x87, 0xC6,
0x96, 0xB9, 0x97, 0xB7, 0x0A, 0xFF, 0xF1, 0x00,
0x4E, 0xA6, 0x5C, 0xE6, 0x3E, 0x7B, 0x2E, 0xF5,
0x3D, 0xFB, 0x50, 0xD7, 0x92, 0xBB, 0x2B, 0xBB,
0xB3, 0xDD, 0x2A, 0x72, 0x2A, 0x1C, 0xC9, 0x66,
0x3D, 0xFC, 0xE8, 0xC8, 0x51, 0x2F, 0x09, 0xBA,
0xCE, 0x48, 0x3C, 0x2B, 0xDC, 0xC6, 0x51, 0xF3,
0x43, 0x53, 0x66, 0x0F, 0xF0, 0x69, 0x2A, 0xBD,
0xB4, 0x0D, 0xB0, 0x4B, 0x68, 0xC9, 0x10, 0x47,
0x1D, 0x96, 0xC0, 0x1E, 0xE8, 0xC2, 0x2E, 0xD9,
0xA2, 0x12, 0x54, 0x79, 0xC1, 0xC6, 0xA8, 0x83,
0xB0, 0xB7, 0x4E, 0xFA, 0x34, 0xB3, 0x3B, 0x45,
0x2A, 0xE4, 0xEA, 0x31, 0x05, 0x9D, 0x90, 0x05,
0x03, 0xE0, 0xAE, 0x9E, 0x21, 0xC3, 0xBA, 0xA9,
0xC5, 0xD5, 0xF4, 0xA4, 0x3D, 0xFC, 0x3F, 0x3B,
0xD2, 0xF3, 0xEA, 0x86, 0x51, 0xF5, 0x95, 0x3E,
0x56, 0x0A, 0x61, 0x43, 0x76, 0x69, 0xB0, 0x07,
0x26, 0x7F, 0xBD, 0x54, 0x9F, 0x45, 0xBD, 0x4D,
0x7B, 0xF6, 0x19, 0x50, 0x09, 0x15, 0xB6, 0x84,
0xC5, 0x05, 0xBD, 0xF2, 0xD6, 0x12, 0x54, 0x40,
0x52, 0x4D, 0xBC, 0x3A, 0xA7, 0x5E, 0x2C, 0xE3,
0xA7, 0x89, 0x85, 0xA4, 0x78, 0x72, 0x85, 0x74,
0x17, 0x51, 0x4A, 0x37, 0xB1, 0x0D, 0xF2, 0x94,
0xE5, 0x69, 0x90, 0x93, 0xA7, 0x94, 0xF0, 0xA1,
0x74, 0x85, 0xB4, 0x39, 0xAE, 0xAF, 0xF5, 0xCC,
0x1C, 0x26, 0xA7, 0x12, 0xD4, 0x52, 0x03, 0x9D,
0x15, 0xF7, 0x0D, 0xC1, 0x20, 0x9A, 0x50, 0xEF,
0x09, 0x88, 0x52, 0xD7, 0x9C, 0xEC, 0x8E, 0x31,
0x53, 0xB2, 0xE2, 0xC8, 0x66, 0x33, 0x62, 0xBB,
0xB6, 0x91, 0x32, 0x0A, 0x1F, 0x87, 0x40, 0x84,
0xA5, 0xBC, 0x12, 0x5B, 0x3E, 0x42, 0x3F, 0xAC,
0xAF, 0x1F, 0xEC, 0x7F, 0x97, 0x13, 0x04, 0xD5,
0xA9, 0xCD, 0x62, 0x21, 0x23, 0xD5, 0xB5, 0x3C,
0x3B, 0xA8, 0xFA, 0x9A, 0x09, 0x9C, 0x0D, 0xFC,
0x2F, 0x83, 0xA5, 0x27, 0x34, 0x61, 0xE5, 0x10,
0xA5, 0x4C, 0x93, 0x06, 0x25, 0xE0, 0x02, 0x71,
0x0D, 0xF5, 0x71, 0xC2, 0x55, 0x6E, 0x80, 0xF9,
0x45, 0xA6, 0xE9, 0x68, 0x31, 0x4B, 0x67, 0xE6,
0xF6, 0xBA, 0x13, 0x9F, 0x87, 0xDE, 0x52, 0xD8,
0x30, 0x2E, 0xD5, 0xDA, 0xBC, 0xFC, 0x78, 0xC9,
0x16, 0xDD, 0x33, 0xCF, 0x8D, 0xFA, 0x2F, 0xB6,
0x55, 0xCB, 0xB1, 0x60, 0xAD, 0xCE, 0x98, 0x3B,
0x53,
0x0C, 0x4F, 0x91, 0x88, 0x50, 0xD8, 0xA3, 0xAD,
0x4A, 0x6C, 0x20, 0x7B, 0xAC, 0x44, 0x98, 0xA5,
0xB6, 0x63, 0xE2, 0x39, 0x27, 0x84, 0xD5, 0x01,
0xD8, 0x80, 0x29, 0x74, 0x7F, 0xC5, 0x91, 0xA3,
0xCA, 0x47, 0xB5, 0x19, 0x34, 0x6B, 0xD6, 0x79,
0xCC, 0x6D, 0x58, 0x40, 0x7F, 0xFF, 0xF5, 0xAF,
0x58, 0xB9, 0x7E, 0x64, 0x24, 0xC8, 0x61, 0xD3,
0x56, 0x3E, 0x49, 0x4D, 0x97, 0xF4, 0xEF, 0xBF,
0x33, 0x43, 0x72, 0xC2, 0x99, 0x6B, 0xB7, 0x23,
0x8C, 0xD8, 0x7B, 0x22, 0x48, 0x16, 0x8B, 0x3C,
0xC6, 0xBD, 0x93, 0x43, 0x57, 0xA7, 0xF9, 0x40,
0x5B, 0x32, 0x0A, 0xEF, 0xA2, 0x5B, 0xA3, 0xF3,
0xDF, 0x91, 0xD8, 0x41, 0x12, 0x10, 0xDD, 0x55,
0xCC, 0x76, 0xCF, 0x56, 0x8D, 0x50, 0xCF, 0x67,
0x44, 0x26, 0xE8, 0xD9, 0xC2, 0x39, 0x64, 0x3B,
0xD2, 0xB3, 0xCA, 0xA8, 0xF7, 0xD7, 0x66, 0x01,
0x1A, 0xAF, 0x59, 0xEA, 0x75, 0x17, 0x17, 0x20,
0x82, 0x05, 0x4E, 0x05, 0x71, 0x0D, 0xDB, 0x38,
0xB1, 0xD8, 0xFB, 0xE2, 0xE0, 0xB4, 0x91, 0xC4,
0x2C, 0x87, 0x6E, 0x35, 0x63, 0x22, 0xBE, 0xCA,
0xF6, 0xF5, 0x2E, 0x20, 0x4D, 0x0A, 0x78, 0xCF,
0xB6, 0x40, 0x36, 0x62, 0x9E, 0x16, 0xCF, 0xDE,
0x32, 0xE1,
0x8C, 0xEE, 0xC2, 0xA8, 0x50, 0x59, 0x59, 0x76,
0xF5, 0x76, 0x41, 0x8D, 0x91, 0xDC, 0x9D, 0xCC,
0x60, 0x85, 0xF0, 0x86, 0xF9, 0x7E, 0x33, 0x2B,
0x3B, 0x77, 0xB6, 0xC3, 0xB1, 0xE3, 0x47, 0x75,
0x0A, 0x4F, 0x82, 0x2E, 0x93, 0x57, 0x17, 0xBB,
0x3E, 0xB3, 0xA0, 0x88, 0x49, 0xD6, 0x81, 0x9F,
0xFD, 0xB8, 0x1C, 0x31, 0xB2, 0x44, 0x13, 0x05,
0x06, 0x3C, 0xD7, 0x83, 0x6E, 0x24, 0xA9, 0x2A,
0x42, 0xEB, 0x35, 0xDF, 0xB6, 0x7B, 0xC4, 0xA0,
0xBE, 0xE7, 0x31, 0x69, 0xD4, 0x8C, 0xD5, 0x6A,
0x82, 0xF5, 0x41, 0x51, 0x3F, 0x8C, 0xFC, 0xB0,
0x05, 0x76, 0x35, 0xC2, 0x2D, 0x1F, 0xC1, 0x8F,
0xA9, 0x58, 0xE5, 0x77, 0x55, 0xC7, 0x51, 0x61,
0xA0, 0xDE, 0x58, 0x84, 0x9C, 0x5C, 0x6C, 0xCB,
0xDB, 0x1D, 0x33, 0x9C, 0xFE, 0x12, 0x0B, 0x59,
0xC5, 0xFF, 0x10, 0x05, 0x68, 0x86, 0x40, 0xCE,
0x6B, 0x4B, 0x15, 0xEB, 0xB9, 0x9B, 0xE0, 0x9F,
0xF5, 0x94, 0x85, 0xCB, 0x47, 0x2B, 0x95, 0xAD,
0x1E, 0x6A, 0x61, 0x35, 0xB1, 0x8F, 0x2A, 0x1D,
0xD3, 0x95, 0xFE, 0xE9, 0x0F, 0x7A, 0x66, 0x23,
0x8E, 0x57, 0xD5, 0xEC, 0x9B, 0x98, 0x50, 0x76,
0xD0, 0x02, 0xCA, 0xF3, 0xAC, 0xB3, 0x08, 0x52,
0x5A, 0x44, 0x7C,
0x3E, 0x2B, 0xCD, 0x86, 0x8B, 0x2E, 0x5F, 0x51,
0x3C, 0xD8, 0x25, 0xF0, 0x78, 0x07, 0xC5, 0xFD,
0x2E, 0xFD, 0x1C, 0xDB, 0x48, 0x47, 0x63, 0xCE,
0xC6, 0xBD, 0xC2, 0x59, 0x71, 0x00, 0xA5, 0xA3,
0xF2, 0xBB, 0x37, 0x77, 0x06, 0x5B, 0xD3, 0x82,
0xBB, 0xC3, 0x03, 0xDD, 0x11, 0xD5, 0x9A, 0xFD,
0x3E, 0x0E, 0xE2, 0x4B, 0x6F, 0x1A, 0xFD, 0x97,
0x93, 0x04, 0x9D, 0xF3, 0xE6, 0xF0, 0xC0, 0x78,
0xBD, 0xBF, 0x6F, 0x60, 0x1A, 0xA3, 0x8F, 0x39,
0x4D, 0xB7, 0x20, 0xEC, 0x6D, 0x31, 0x1D, 0xF1,
0xF6, 0x3D, 0xF3, 0xAD, 0x3B, 0xA3, 0xEA, 0xF9,
0xCF, 0x73, 0x42, 0x32, 0xC0, 0x1E, 0x21, 0x55,
0x50, 0xE3, 0x5F, 0xE4, 0xF6, 0x34, 0x24, 0xF6,
0x1F, 0x42, 0x7C, 0x83, 0x07, 0x56, 0x60, 0x12,
0x4D, 0x5B, 0x83, 0x39, 0x3C, 0x27, 0xF9, 0x2D,
0xB8, 0xDC, 0x27, 0xBF, 0x5D, 0xCB, 0x0D, 0x9C,
0xDE, 0x82, 0xC6, 0xBA, 0x3F, 0x79, 0x30, 0x73,
0x92, 0xC0, 0xC1, 0x65, 0x52, 0x06, 0xAC, 0x33,
0x55, 0x13, 0x77, 0xFC, 0x6F, 0x85, 0x12, 0xB6,
0x04, 0x24, 0x0B, 0x3C, 0x82, 0x31, 0x58, 0x18,
0xCE, 0xBC, 0x7D, 0x73, 0x4D, 0x3A, 0xEC, 0x8E,
0xEB, 0x94, 0xC9, 0x93, 0x49, 0x66, 0xA6, 0xF0,
0x2D, 0xBF, 0x2D, 0x48,
0x94, 0xB1, 0xB3, 0xCB, 0x7B, 0xD8, 0xC7, 0xB1,
0xB4, 0x97, 0xC5, 0x63, 0xF2, 0x93, 0x92, 0x8B,
0x03, 0x92, 0x31, 0x35, 0x00, 0xA9, 0xD9, 0x34,
0x22, 0x80, 0x72, 0x27, 0x2F, 0x7D, 0x47, 0x8F,
0x43, 0xBD, 0x22, 0x1A, 0xB7, 0x66, 0x9E, 0xEB,
0x9D, 0x5F, 0x43, 0xEE, 0x51, 0x9D, 0x0C, 0xE5,
0x0D, 0x63, 0xF4, 0x05, 0x76, 0xC9, 0x32, 0x70,
0xC4, 0x57, 0xEA, 0x3C, 0x32, 0x3C, 0x87, 0x33,
0x63, 0x8F, 0x4D, 0xA8, 0xD9, 0x17, 0x89, 0x07,
0xE0, 0xB0, 0x32, 0x9A, 0x17, 0x0B, 0x2E, 0x91,
0xD6, 0xF0, 0x9E, 0x54, 0xC9, 0x72, 0x8E, 0x69,
0xB8, 0x88, 0x10, 0x4B, 0x53, 0xA7, 0x05, 0xF4,
0x92, 0xC8, 0xF6, 0xEC, 0x7E, 0x72, 0x27, 0x8B,
0x4F, 0x04, 0x12, 0x44, 0x47, 0x19, 0xAE, 0xBA,
0x95, 0xE0, 0x63, 0xDF, 0x83, 0x44, 0xC2, 0x14,
0x81, 0x45, 0xE3, 0xD9, 0xFC, 0xF7, 0xF9, 0x35,
0x14, 0xFC, 0x18, 0xAD, 0x8D, 0x52, 0x80, 0xE4,
0xBC, 0x6A, 0x5A, 0x36, 0x05, 0x02, 0xA1, 0x76,
0xE8, 0x77, 0xF3, 0xC3, 0x9D, 0xE9, 0x44, 0x78,
0x0E, 0x17, 0xAD, 0x4F, 0x0C, 0xA8, 0x13, 0xC2,
0x6F, 0x48, 0x06, 0xB7, 0x8A, 0x6C, 0x10, 0x77,
0xC0, 0x95, 0x5C, 0x7E, 0x1D, 0x70, 0xC7, 0x4D,
0x10, 0x7D, 0x25, 0x60, 0xDD,
0x4B, 0xAD, 0x00, 0xAC, 0xBE, 0x17, 0x82, 0x92,
0x04, 0x5E, 0x1D, 0x0A, 0x64, 0xB0, 0x05, 0x97,
0x36, 0x62, 0x62, 0x60, 0xEE, 0x11, 0x1A, 0x39,
0x4B, 0x9E, 0xAA, 0x23, 0xF1, 0x78, 0x4B, 0x78,
0x28, 0xDD, 0x2D, 0x49, 0xAE, 0x8C, 0xDC, 0xAD,
0x07, 0x58, 0xA9, 0x6B, 0x47, 0xFB, 0xF3, 0x6B,
0x6A, 0xE1, 0xE4, 0x40, 0xCC, 0x86, 0x87, 0x75,
0xC5, 0xC1, 0x67, 0xCF, 0x05, 0xD7, 0x01, 0x33,
0xBA, 0x04, 0x7A, 0xA0, 0x98, 0xE8, 0x9C, 0x18,
0x55, 0xCE, 0xCE, 0x18, 0x20, 0x01, 0x3D, 0xFB,
0x0A, 0xE8, 0xFE, 0x17, 0x00, 0xF4, 0x04, 0x4B,
0xB7, 0xA2, 0x0D, 0xA9, 0x47, 0xDA, 0xC2, 0x59,
0xE3, 0xDE, 0x93, 0x2C, 0x2C, 0x1D, 0x1C, 0x89,
0x9A, 0xAD, 0x1A, 0x12, 0xFF, 0x22, 0x26, 0x76,
0x38, 0x03, 0x78, 0xBF, 0x3B, 0x82, 0x96, 0x54,
0x12, 0x7B, 0x6F, 0x4A, 0x2D, 0x66, 0x22, 0x90,
0xDE, 0x95, 0x4D, 0x98, 0x9F, 0xD1, 0x57, 0xF5,
0x7E, 0x6C, 0x39, 0xB6, 0xBF, 0x75, 0x25, 0x15,
0x86, 0xB1, 0xEF, 0xC1, 0x7F, 0x5C, 0x0C, 0xB0,
0x0C, 0xFE, 0xCD, 0x76, 0x66, 0xCD, 0xED, 0x3B,
0x32, 0xFE, 0x75, 0x16, 0x50, 0x71, 0x00, 0xBA,
0x70, 0x5E, 0xCA, 0xA1, 0xB1, 0xB9, 0x4F, 0x2A,
0x36, 0xF0, 0x3D, 0x2D, 0x37, 0x35,
0x06, 0xF7, 0x42, 0x13, 0x5B, 0x0A, 0x88, 0xE5,
0x0F, 0x70, 0x11, 0x46, 0x86, 0xB0, 0x48, 0x21,
0x71, 0xB8, 0x03, 0x4A, 0xED, 0x50, 0xF9, 0x28,
0x6C, 0x69, 0xA5, 0x56, 0x7F, 0x92, 0x4B, 0xDB,
0x28, 0xC6, 0x14, 0x2C, 0x5A, 0xE4, 0xD5, 0x35,
0x3F, 0x75, 0x56, 0xD0, 0xCF, 0xAD, 0x64, 0xF0,
0x42, 0x34, 0x07, 0x70, 0x07, 0x80, 0xB7, 0xE4,
0xCF, 0xF7, 0xE5, 0xB6, 0x67, 0x1C, 0xBE, 0xB7,
0xF8, 0x9B, 0xCD, 0x92, 0xB2, 0x81, 0xE4, 0xFB,
0xC5, 0xBC, 0xDD, 0xD3, 0x5D, 0xBC, 0x1E, 0x65,
0xDC, 0xDB, 0xFA, 0x1B, 0xEF, 0xA6, 0x33, 0x87,
0x55, 0x88, 0xBF, 0x0B, 0xBD, 0x86, 0x45, 0xA0,
0x40, 0x15, 0x25, 0xE9, 0x12, 0x50, 0x58, 0x6B,
0x5E, 0x43, 0xE3, 0x34, 0x60, 0xFC, 0x17, 0x86,
0x69, 0xE5, 0x42, 0xA3, 0xE9, 0x2E, 0xFE, 0xEF,
0xA7, 0x03, 0x2B, 0xD2, 0x29, 0x5E, 0xDA, 0xC3,
0x8A, 0xB4, 0x50, 0x40, 0x88, 0x21, 0x24, 0x1F,
0xE6, 0x14, 0x75, 0x06, 0xCA, 0x6F, 0x2F, 0x06,
0x5E, 0x47, 0x25, 0x01, 0xD2, 0xAF, 0xFD, 0xB5,
0xE1, 0xDF, 0x24, 0xFD, 0x81, 0x39, 0xB0, 0x1E,
0x3B, 0x79, 0xAB, 0xA2, 0x53, 0xCB, 0x3F, 0x37,
0x84, 0x83, 0xC6, 0xD6, 0xC0, 0xDD, 0x2C, 0xB1,
0xFA, 0x56, 0xFB, 0x54, 0x71, 0x06, 0x9D,
0x88, 0xF8, 0x68, 0xE6, 0x97, 0xD7, 0xF7, 0xAC,
0x17, 0x60, 0xF9, 0xA2, 0x90, 0x89, 0x20, 0xCE,
0x34, 0x12, 0x5B, 0x06, 0xFF, 0x63, 0xD0, 0xAC,
0xF6, 0x8B, 0x3F, 0x62, 0xB0, 0x59, 0x80, 0x36,
0xD2, 0xB8, 0xE5, 0xAC, 0xC7, 0x31, 0xB7, 0x8C,
0xF1, 0x8B, 0x7F, 0x2D, 0x8A, 0x30, 0xB7, 0x84,
0x6A, 0x63, 0x09, 0x97, 0xC2, 0x4C, 0xA2, 0xBC,
0xCD, 0x13, 0xC1, 0x8E, 0xB1, 0xE8, 0x39, 0x4E,
0x68, 0x0E, 0xF8, 0xA1, 0x1E, 0x22, 0x2A, 0x6D,
0xF8, 0x1F, 0x69, 0xE1, 0xAA, 0x66, 0x76, 0xCD,
0xD3, 0x31, 0x27, 0x16, 0x27, 0xC5, 0x1E, 0x26,
0x69, 0x02, 0x2E, 0x37, 0x31, 0xAC, 0x6E, 0x15,
0x78, 0xC1, 0x38, 0xD5, 0x0E, 0x57, 0x45, 0x57,
0x4F, 0x8C, 0x88, 0x54, 0x19, 0xAC, 0x26, 0xFE,
0xB3, 0xBF, 0x70, 0xE0, 0x0F, 0x00, 0xAE, 0x3F,
0xE4, 0x7E, 0x10, 0xE7, 0x5A, 0x97, 0x54, 0x80,
0xF4, 0x34, 0x3A, 0x1C, 0xAE, 0xE0, 0x97, 0xD1,
0x9B, 0xFD, 0x39, 0xC9, 0x41, 0x9E, 0xEE, 0x75,
0xC4, 0x25, 0xC7, 0x61, 0xA3, 0x22, 0xA4, 0x21,
0x32, 0xA0, 0xCC, 0x29, 0x45, 0xC0, 0xFE, 0x8F,
0x38, 0xE1, 0x87, 0x9D, 0xFD, 0x22, 0xBF, 0xDB,
0xE7, 0x78, 0x41, 0x87, 0x12, 0xF3, 0xF9, 0x09,
0x28, 0x0A, 0x9D, 0x3D, 0xA3, 0x2E, 0x27, 0xBA,
0x3D, 0x8E, 0x75, 0x19, 0xBC, 0xCD, 0x82, 0x55,
0x4D, 0x7F, 0x9C, 0x49, 0xD9, 0x34, 0xDF, 0xA3,
0x92, 0x24, 0x8A, 0xC9, 0x75, 0x65, 0x49, 0x0D,
0x2F, 0x41, 0x0D, 0x0E, 0xB5, 0x06, 0x0C, 0xC7,
0x95, 0xF2, 0x0F, 0x42, 0xA5, 0xED, 0xCB, 0x50,
0x38, 0xC8, 0xC0, 0x39, 0xDE, 0xBF, 0x0A, 0x20,
0x9E, 0x7A, 0x0E, 0x15, 0x24, 0x68, 0x4F, 0x9C,
0xF6, 0x99, 0x46, 0xDD, 0x20, 0xE2, 0x7F, 0x32,
0x95, 0x6D, 0x1A, 0x92, 0x7F, 0x70, 0x0E, 0x3C,
0xC0, 0xA0, 0x65, 0x2B, 0xC3, 0x53, 0xE4, 0x62,
0xA8, 0x17, 0xC7, 0xE4, 0xE0, 0xC1, 0xA2, 0xA9,
0xF7, 0xF3, 0x43, 0xA3, 0xD1, 0xDA, 0x6C, 0x99,
0x89, 0x7C, 0x30, 0x47, 0x80, 0x0D, 0x4F, 0xEE,
0x45, 0xCC, 0x25, 0x56, 0x27, 0x37, 0x14, 0xE8,
0x4C, 0x33, 0x49, 0x1B, 0xA6, 0x9F, 0xC7, 0x8A,
0x1A, 0xE4, 0xCD, 0xDF, 0xEE, 0x09, 0x20, 0x79,
0x33, 0x5C, 0xEC, 0x43, 0x57, 0xCA, 0x5D, 0xC6,
0x80, 0xEC, 0xA5, 0x99, 0x64, 0xD5, 0x85, 0xE5,
0xEE, 0x92, 0x48, 0xCE, 0x01, 0xA1, 0x55, 0x57,
0xCE, 0xAA, 0x5A, 0x93, 0x07, 0x95, 0x03, 0x66,
0xE3, 0xAD, 0x2B, 0x45, 0x64, 0xC8, 0x68, 0x87,
0x58, 0xF5, 0xE2, 0x42, 0xCB, 0x18, 0x37, 0xE0,
0x32, 0x9B, 0x2A, 0x79, 0x2C, 0x8F, 0xB8, 0x35,
0xE9,
0xF8, 0x38, 0x98, 0x68, 0x1C, 0x04, 0xB5, 0x9B,
0x41, 0x37, 0xB2, 0x95, 0x2B, 0x34, 0xFD, 0x15,
0xF1, 0x54, 0x66, 0x92, 0xFC, 0xF3, 0xF1, 0xB3,
0xD9, 0x73, 0x03, 0x50, 0xA9, 0x38, 0x8E, 0x45,
0x9B, 0x70, 0xF3, 0x8A, 0x53, 0xE6, 0x90, 0x07,
0x03, 0x96, 0xBD, 0xAF, 0xB2, 0x44, 0x36, 0xA2,
0x5D, 0x25, 0x9D, 0x72, 0xFE, 0x24, 0xDB, 0xA4,
0x7E, 0x75, 0x41, 0xB9, 0x0F, 0xFB, 0xBA, 0xE8,
0x52, 0x41, 0xF6, 0xA4, 0xE1, 0xF5, 0x48, 0x8A,
0xE9, 0xFE, 0x1F, 0x83, 0xDE, 0x32, 0x78, 0x51,
0x39, 0x49, 0x82, 0x00, 0x47, 0x0B, 0xB3, 0xC2,
0x89, 0x11, 0x15, 0xDF, 0x09, 0xC5, 0x7B, 0xFC,
0x8E, 0xA3, 0xAA, 0x1A, 0x6F, 0x24, 0x53, 0x9D,
0x0A, 0x22, 0x26, 0x30, 0x8D, 0x96, 0x6D, 0x76,
0x0C, 0x79, 0x38, 0x82, 0xB1, 0x6D, 0x11, 0xE1,
0xA3, 0x41, 0xBC, 0xC4, 0x80, 0xA3, 0xAB, 0x67,
0x8C, 0x0E, 0x7A, 0x1F, 0x2A, 0x26, 0x07, 0xE3,
0xBE, 0x25, 0x71, 0x6D, 0xEE, 0x55, 0x07, 0xA7,
0x48, 0xFD, 0x1B, 0xAB, 0xC9, 0x58, 0x2A, 0xA3,
0xA5, 0x82, 0xEC, 0x46, 0x9D, 0x34, 0xB5, 0x19,
0x02, 0x3B, 0xC5, 0xE3, 0x4A, 0xBF, 0xD4, 0x6A,
0xAD, 0x7E, 0xD6, 0x5C, 0x43, 0xD7, 0xAE, 0xA7,
0x78, 0x67, 0xED, 0xC1, 0xA8, 0xBF, 0xDA, 0x07,
0xEA, 0x3F,
0x20, 0xE6, 0x7C, 0x30, 0x83, 0x82, 0x34, 0xA4,
0x1F, 0x15, 0x45, 0x2C, 0x5F, 0xAF, 0x3B, 0xEC,
0x63, 0x12, 0xC9, 0x7E, 0x16, 0xF1, 0xB9, 0xCD,
0xCA, 0x99, 0x04, 0x65, 0xA6, 0xF9, 0x46, 0xF8,
0x15, 0x01, 0xAE, 0x42, 0x57, 0xB1, 0x91, 0xDC,
0x83, 0xD7, 0x19, 0xA8, 0x4D, 0x9C, 0x34, 0x55,
0x4C, 0x52, 0xE7, 0x09, 0xA6, 0xE6, 0xEB, 0x04,
0xCC, 0x63, 0xCB, 0xC6, 0x0C, 0x57, 0xCC, 0xFD,
0x9F, 0xD8, 0x4B, 0x31, 0xB8, 0xF8, 0xFD, 0xB5,
0xCA, 0x2C, 0xC1, 0x60, 0xCC, 0xC1, 0x52, 0x64,
0x16, 0xA4, 0x57, 0x6A, 0x01, 0xCB, 0xAE, 0x74,
0x3A, 0x85, 0x1A, 0xD7, 0x6E, 0xA6, 0xBA, 0x42,
0x3C, 0x6C, 0xA4, 0x31, 0x53, 0x04, 0x07, 0xCA,
0x57, 0x24, 0x8C, 0x1D, 0xCD, 0x55, 0x6A, 0xC5,
0xF3, 0xDF, 0xD1, 0xEF, 0x04, 0xB1, 0x4F, 0x87,
0x16, 0xFB, 0x6F, 0xC9, 0xB7, 0x1B, 0xD0, 0xC0,
0x2B, 0xB2, 0x01, 0x4A, 0xBB, 0x54, 0xBA, 0xE6,
0xF3, 0x67, 0x3F, 0xB5, 0xD2, 0x1C, 0x79, 0x7F,
0x4A, 0x6F, 0x99, 0xBE, 0xFC, 0x70, 0xD5, 0x52,
0xFE, 0xFF, 0xA0, 0x0A, 0x6A, 0x61, 0x47, 0x8C,
0x25, 0x6E, 0x99, 0x55, 0x86, 0x19, 0x42, 0xC6,
0x2F, 0x39, 0x01, 0x77, 0x0F, 0x6F, 0x1C, 0x1D,
0xC8, 0xAF, 0x1D, 0x6E, 0x35, 0xD2, 0x7D, 0x3F,
0x5E, 0x4F, 0x74,
0x8D, 0xA9, 0x54, 0x7F, 0xBF, 0xB6, 0xC2, 0x10,
0x29, 0xF7, 0x34, 0xA4, 0x1B, 0x7F, 0xEF, 0xDB,
0x36, 0xD0, 0x83, 0x73, 0x7C, 0x3E, 0xA8, 0x62,
0x75, 0x31, 0x09, 0xAC, 0x11, 0x1B, 0x70, 0x8A,
0x81, 0x99, 0x30, 0xF4, 0x92, 0x6F, 0xF7, 0xDC,
0xB2, 0x52, 0x6E, 0xD5, 0xBA, 0x31, 0xD1, 0x83,
0x7E, 0x19, 0x75, 0x4A, 0xA1, 0xCE, 0x65, 0x04,
0x61, 0xAB, 0x8B, 0x21, 0x4F, 0x48, 0x4C, 0xD6,
0x08, 0x87, 0x2A, 0xBF, 0x68, 0x95, 0x53, 0x96,
0xC1, 0x63, 0x81, 0x85, 0x08, 0xA7, 0xC1, 0x27,
0x0C, 0x1F, 0xAA, 0xAF, 0xF3, 0x66, 0x57, 0xA4,
0xA2, 0xB5, 0x57, 0x63, 0xAC, 0xDC, 0xAE, 0x97,
0xA0, 0x2F, 0x63, 0x84, 0x2F, 0x1B, 0x62, 0x88,
0xFB, 0xBD, 0x18, 0x70, 0xEF, 0x54, 0xDB, 0xF3,
0x6D, 0x8F, 0xD6, 0xB0, 0x23, 0xE5, 0x4D, 0xC1,
0xB2, 0xED, 0xC2, 0xB7, 0xF7, 0xD1, 0xAE, 0x59,
0xB9, 0xF3, 0x62, 0x3F, 0x5F, 0xAA, 0x2B, 0xA1,
0xB9, 0xBA, 0x91, 0x47, 0x67, 0x15, 0xCE, 0x2A,
0x66, 0x88, 0xC8, 0x2D, 0x5B, 0xA3, 0xD1, 0x2D,
0x64, 0x25, 0x8F, 0xEC, 0xB2, 0x57, 0xAB, 0xCC,
0x6A, 0x24, 0x9B, 0xE5, 0x9A, 0x84, 0xD0, 0x53,
0x20, 0x89, 0xB3, 0x9A, 0xBF, 0xA6, 0x31, 0xB4,
0x8A, 0x89, 0x83, 0x87, 0xDE, 0xDE, 0xBF, 0x84,
0x62, 0x64, 0x5C, 0x53,
0x9B, 0x81, 0x4A, 0xB2, 0x99, 0x41, 0x14, 0xF6,
0xE7, 0x36, 0xF9, 0x91, 0x04, 0xC0, 0x46, 0x27,
0x9A, 0x07, 0x20, 0x32, 0xFF, 0xA2, 0x57, 0xC8,
0xB5, 0xE8, 0xF8, 0x64, 0xB0, 0x7D, 0x05, 0x2B,
0x90, 0xF2, 0xC9, 0x33, 0xC4, 0x81, 0xD9, 0x31,
0x25, 0x31, 0x79, 0x08, 0xC4, 0x01, 0x2C, 0x5C,
0x45, 0xC4, 0x94, 0x15, 0xE8, 0x48, 0x4E, 0x9B,
0x38, 0x0D, 0x81, 0x95, 0x79, 0xB5, 0x78, 0x55,
0x1F, 0xE1, 0xFC, 0x39, 0xA6, 0xDE, 0x97, 0x79,
0xFF, 0x20, 0x8B, 0x32, 0xFF, 0x84, 0x42, 0xBB,
0xB0, 0xF5, 0xD7, 0xDA, 0x8C, 0x3C, 0xE5, 0x5D,
0x7C, 0x99, 0x70, 0xE2, 0xF2, 0xA8, 0xD0, 0x47,
0xF1, 0x85, 0xC9, 0xD2, 0xF9, 0xFF, 0x14, 0x56,
0x34, 0xED, 0xDE, 0x51, 0x12, 0x2B, 0xF8, 0x55,
0x31, 0xE0, 0x02, 0x87, 0x52, 0x52, 0xEF, 0x17,
0x01, 0x9B, 0x52, 0x21, 0x9E, 0x38, 0xEC, 0xFF,
0xF2, 0x33, 0x8F, 0xE4, 0x9A, 0x2F, 0x27, 0x51,
0xE8, 0x5D, 0xD0, 0x61, 0xEA, 0x81, 0xC3, 0x55,
0x1C, 0x23, 0xA2, 0xC4, 0xA9, 0x88, 0xE1, 0x67,
0xCE, 0xD8, 0x04, 0xD7, 0xF2, 0xC7, 0x86, 0xF0,
0xF2, 0x87, 0x87, 0xBF, 0x44, 0x5D, 0x99, 0x65,
0x99, 0x99, 0x2F, 0x2C, 0x49, 0xE2, 0xC9, 0x4D,
0xEC, 0xAC, 0xFD, 0xF2, 0x76, 0x7C, 0x9E, 0x49,
0xE2, 0xD2, 0xDD, 0x60, 0x41,
0x33, 0x4E, 0x46, 0xDB, 0xFA, 0x46, 0x21, 0xAE,
0x74, 0xC9, 0x52, 0x24, 0x61, 0xFC, 0xE4, 0x60,
0xF8, 0xBC, 0x19, 0x97, 0x6B, 0x8D, 0x36, 0x7E,
0x85, 0xBB, 0x01, 0x4B, 0xEE, 0x8A, 0x99, 0xD2,
0x43, 0x1C, 0x11, 0xCB, 0x79, 0x98, 0xD2, 0x08,
0x96, 0x80, 0x07, 0xF9, 0x90, 0xE7, 0x57, 0x0A,
0x47, 0xB8, 0xFC, 0x33, 0x02, 0xBF, 0x75, 0xB2,
0x9C, 0xF9, 0x9E, 0x47, 0xFA, 0x5B, 0x53, 0xC6,
0x74, 0x98, 0x88, 0xE1, 0x24, 0x62, 0x9F, 0x4C,
0xF6, 0xA9, 0x45, 0x7D, 0xA6, 0x45, 0x5A, 0x75,
0xA5, 0x98, 0x8E, 0xE9, 0xA2, 0x65, 0x60, 0x74,
0x46, 0xC6, 0x38, 0xEB, 0xED, 0x9E, 0xEA, 0x94,
0x1C, 0x86, 0x91, 0xED, 0x0E, 0x09, 0xEB, 0xA3,
0x36, 0x8D, 0x5A, 0x31, 0xB1, 0xC0, 0xA0, 0x82,
0x88, 0x68, 0xEA, 0x28, 0x45, 0xBB, 0x9C, 0xF8,
0x28, 0x77, 0xF1, 0x2E, 0xCA, 0x00, 0xC6, 0xB7,
0x53, 0x23, 0x7D, 0x9A, 0x9F, 0x67, 0x68, 0x6D,
0xA2, 0x85, 0x4F, 0xDD, 0x55, 0xAB, 0x3C, 0x71,
0x6C, 0x99, 0x9F, 0x81, 0xD7, 0x7F, 0xA5, 0x50,
0x78, 0xAC, 0x01, 0x18, 0x57, 0xC3, 0xC8, 0x4E,
0xCC, 0x22, 0x40, 0xBC, 0xFC, 0xBA, 0xA2, 0x37,
0xB9, 0x96, 0x44, 0xEE, 0x8D, 0xE7, 0xC2, 0xDA,
0x1D, 0xCC, 0x0A, 0x42, 0x48, 0x48, 0xD1, 0x8E,
0xBA, 0x75, 0x23, 0xF3, 0x98, 0x5E,
0x0D, 0x99, 0x62, 0x84, 0xF7, 0xB6, 0x3F, 0x9C,
0x0F, 0x49, 0x6A, 0xBC, 0x46, 0x9C, 0x98, 0x37,
0xC8, 0xDA, 0xC2, 0xFC, 0xFA, 0x9E, 0x64, 0x43,
0x8D, 0x85, 0x9C, 0x0C, 0x42, 0x18, 0xD4, 0x44,
0x3F, 0xB7, 0xDC, 0x0E, 0xCF, 0x17, 0x6C, 0xD6,
0x7C, 0xE4, 0x2C, 0x91, 0xDC, 0x07, 0x0C, 0x77,
0x2F, 0x0C, 0xB6, 0x95, 0x43, 0x29, 0x9D, 0xD0,
0x66, 0x10, 0x57, 0xAB, 0x3C, 0xCA, 0x10, 0x9B,
0x95, 0x2F, 0x41, 0xB2, 0x03, 0x2A, 0x86, 0x80,
0x40, 0x51, 0x7B, 0x15, 0xFE, 0xAE, 0xA4, 0xA5,
0xAE, 0x00, 0xF3, 0x97, 0x9A, 0x6E, 0xDD, 0x79,
0xB7, 0x9C, 0x60, 0xC1, 0x64, 0xB5, 0x6E, 0x0A,
0x10, 0x24, 0x12, 0x7F, 0xEC, 0x81, 0xC8, 0xE3,
0xA8, 0xC3, 0x67, 0xFC, 0x24, 0x00, 0x8F, 0x43,
0x53, 0x3B, 0x08, 0x00, 0x1F, 0x94, 0xEE, 0x49,
0xD0, 0x87, 0xD7, 0x93, 0x9D, 0x86, 0x2B, 0x56,
0x14, 0x24, 0xE2, 0xC5, 0x81, 0x17, 0x00, 0xAE,
0x35, 0x84, 0xDE, 0xC9, 0x2C, 0xCF, 0x1B, 0xC2,
0x8A, 0xC4, 0x05, 0xFD, 0xA2, 0x83, 0x7D, 0x40,
0xA4, 0x03, 0xBE, 0x14, 0x74, 0x97, 0xED, 0x25,
0xC8, 0xD5, 0x6D, 0xCA, 0x06, 0xB0, 0x12, 0x0F,
0x1D, 0xEB, 0xD2, 0xF1, 0x6E, 0x53, 0x09, 0xAC,
0xE2, 0x0B, 0xF6, 0xDB, 0x0C, 0xC3, 0x1D, 0xAC,
0x9B, 0x2E, 0x9B, 0x72, 0xFD, 0x50, 0x58,
0x6E, 0xE2, 0xD6, 0xFF, 0xBD, 0x1B, 0x11, 0x30,
0xD2, 0xCD, 0x1E, 0xD5, 0xBC, 0xEE, 0x73, 0x7A,
0x93, 0x44, 0x92, 0xCE, 0xD0, 0x27, 0xA0, 0x87,
0xF1, 0x0B, 0xAA, 0x07, 0x27, 0x14, 0x68, 0x65,
0x37, 0x37, 0xB7, 0xA4, 0xCE, 0x31, 0x94, 0x9E,
0x7E, 0x17, 0x28, 0x36, 0x01, 0x68, 0x3C, 0x6B,
0x0D, 0xEA, 0x79, 0x85, 0xAC, 0x43, 0xA1, 0x53,
0x01, 0x8D, 0x47, 0x8E, 0x16, 0x23, 0xB3, 0xF6,
0xC1, 0x8A, 0x17, 0x0E, 0x1E, 0xB2, 0x53, 0x5F,
0x09, 0x66, 0x0A, 0xAF, 0x80, 0xA0, 0xDB, 0xBB,
0x19, 0x16, 0x7C, 0x12, 0x4D, 0xE0, 0x70, 0xC4,
0xDD, 0x2D, 0xF1, 0x76, 0xB6, 0x28, 0xE6, 0xB5,
0x96, 0xFD, 0x38, 0xCD, 0x14, 0xBA, 0xF0, 0x46,
0x4A, 0x2B, 0xD1, 0x41, 0x36, 0x18, 0x23, 0x14,
0x49, 0x9E, 0xE4, 0x3E, 0x5C, 0x55, 0xDD, 0x0B,
0xF3, 0x81, 0xDF, 0xEA, 0x94, 0x3E, 0x1A, 0xC6,
0xD3, 0x3A, 0xD0, 0x56, 0xFA, 0xB0, 0x3A, 0x06,
0xAA, 0x95, 0xD6, 0x9D, 0xAE, 0xA6, 0xCB, 0x69,
0x74, 0x6A, 0x23, 0xDA, 0xCD, 0x8D, 0xE1, 0x47,
0x3A, 0x9E, 0x6E, 0x54, 0xF1, 0x17, 0x9C, 0xB2,
0xC4, 0x7F, 0x2E, 0x96, 0xF8, 0x05, 0xCC, 0xA9,
0x04, 0xC5, 0xD8, 0x58, 0x6A, 0x14, 0x4C, 0x6C,
0x79, 0xCA, 0x57, 0x8D, 0xC7, 0x11, 0x0A, 0x50,
0x97, 0xCA, 0xC5, 0xC8, 0x7A, 0x4F, 0xD4, 0x14,
0x29, 0x01, 0xB7, 0xA9, 0xBC, 0x69, 0xEF, 0x33,
0xB4, 0x6B, 0x29, 0x59, 0x89, 0x21, 0xB5, 0x22,
0xDE, 0xCC, 0xAF, 0x7D, 0xBD, 0xC5, 0xAC, 0x5A,
0x90, 0x95, 0xA4, 0x90, 0x4B, 0x2C, 0xCB, 0x92,
0xE9, 0x50, 0xA8, 0x58, 0xE6, 0x41, 0xE8, 0x8E,
0x50, 0x4E, 0xB9, 0xDE, 0xC6, 0x19, 0x58, 0x72,
0xD3, 0xB9, 0xC8, 0xAB, 0x7B, 0xB6, 0xA7, 0x37,
0xF0, 0x55, 0x2A, 0x0F, 0x9F, 0x08, 0x07, 0x70,
0xBE, 0x53, 0xF0, 0x1C, 0xD0, 0x13, 0xCF, 0x49,
0xE3, 0xF0, 0x3E, 0x04, 0xEA, 0xC2, 0x4D, 0x18,
0x75, 0xC8, 0xA2, 0x56, 0x4E, 0x03, 0x40, 0x27,
0x37, 0x8D, 0x8E, 0x10, 0xF1, 0x01, 0xC2, 0xBA,
0x13, 0xA0, 0x57, 0x82, 0x66, 0x7B, 0x4A, 0x6E,
0xE3, 0x58, 0xD9, 0x1C, 0x36, 0xB5, 0x70, 0x7F,
0x7E, 0xE0, 0x42, 0xDA, 0x22, 0x9A, 0x54, 0x9E,
0xB7, 0xCF, 0x4E, 0xF0, 0xA7, 0xDA, 0xE0, 0xE7,
0x05, 0x86, 0x5C, 0xC5, 0xB5, 0xBE, 0x96, 0x39,
0x60, 0x73, 0x42, 0xD3, 0x1F, 0xD3, 0x53, 0xC8,
0x20, 0x4D, 0xA9, 0xB5, 0xD6, 0x05, 0xC5, 0x7D,
0x28, 0x49, 0xF6, 0x69, 0x3D, 0x97, 0x32, 0xA3,
0x04, 0x21, 0x6B, 0x20, 0x4D, 0x84, 0x5C, 0xF8,
0x9E, 0x88, 0x1F, 0x65, 0xE4, 0x69, 0x5D, 0x68,
0x42, 0xB9, 0xBE, 0xCC, 0x3C, 0xDC, 0x3F, 0x32,
0xBD, 0x3A, 0x4C, 0xEB, 0x8E, 0x97, 0x1C, 0xAD,
0xCB,
0x2C, 0xDA, 0x63, 0x67, 0xDD, 0xD5, 0xA0, 0xAD,
0x02, 0xCD, 0xB0, 0x0F, 0xB7, 0x6E, 0x44, 0x86,
0x4E, 0x63, 0x83, 0x64, 0x66, 0xE1, 0xAE, 0xE9,
0x03, 0xF5, 0x93, 0x7F, 0xB1, 0xAD, 0xC5, 0x3A,
0xFA, 0x6B, 0x64, 0xA4, 0xBD, 0xAB, 0x90, 0x0A,
0x2E, 0x5B, 0x08, 0x3E, 0xDC, 0x8F, 0x8C, 0xF7,
0xF0, 0x44, 0x91, 0x40, 0x78, 0xD6, 0x5D, 0x2A,
0x70, 0x17, 0xBC, 0xB0, 0xD1, 0x97, 0x14, 0xDC,
0x45, 0xE2, 0x5C, 0x20, 0x2D, 0x21, 0x74, 0x58,
0xD5, 0x9D, 0x2A, 0x51, 0xC4, 0x66, 0xE1, 0x3F,
0x23, 0xEC, 0xBB, 0x19, 0x45, 0xE0, 0x43, 0xDB,
0x84, 0x32, 0x6F, 0x98, 0xDF, 0x3A, 0xC4, 0xDB,
0x57, 0x5B, 0xB9, 0xE2, 0x18, 0x55, 0x4E, 0xE4,
0x60, 0x41, 0x65, 0x7B, 0xA4, 0x9D, 0x9B, 0x39,
0x28, 0x22, 0x2B, 0xAC, 0x0C, 0x7C, 0x9E, 0x6F,
0x58, 0x46, 0x60, 0x89, 0xD9, 0xE2, 0x88, 0xAD,
0x39, 0x85, 0x67, 0x24, 0xA3, 0x1A, 0x6A, 0x7A,
0xAD, 0xCF, 0x10, 0x98, 0x40, 0x79, 0x46, 0x5C,
0xC9, 0xE4, 0x8A, 0xE5, 0x40, 0x40, 0x76, 0x71,
0x9F, 0xDE, 0xAA, 0x6C, 0x83, 0x5B, 0xCD, 0x4F,
0x99, 0xD9, 0xA0, 0x48, 0xBC, 0xFC, 0xCA, 0xAC,
0x0A, 0x2B, 0xD4, 0x06, 0x30, 0x38, 0x20, 0x27,
0x90, 0xF1, 0x5E, 0x85, 0x3D, 0xFA, 0xDA, 0x2B,
0x8F, 0xAF, 0x0A, 0x1C, 0xDA, 0x71, 0xB0, 0x0A,
0xB0, 0x28,
0x91, 0x59, 0x87, 0x84, 0xE1, 0x67, 0x46, 0x45,
0xC8, 0xAC, 0x92, 0xC7, 0xED, 0x99, 0x2C, 0x44,
0x6D, 0x85, 0x82, 0x50, 0x45, 0x87, 0x53, 0x8E,
0x20, 0xBE, 0x15, 0x47, 0xB0, 0x65, 0x09, 0xC2,
0x07, 0xD3, 0x83, 0x8F, 0xEA, 0x63, 0x56, 0x09,
0x4F, 0x45, 0xAA, 0x51, 0x8B, 0x84, 0xDF, 0x56,
0x87, 0x21, 0x31, 0xAA, 0x52, 0x2D, 0x5D, 0x34,
0xC6, 0x57, 0xA1, 0xB7, 0xCB, 0x57, 0x25, 0x85,
0xD4, 0x86, 0x9D, 0x36, 0x52, 0xC1, 0x1A, 0x29,
0x3B, 0xD6, 0x03, 0x1F, 0x27, 0xBE, 0x3D, 0x39,
0x28, 0xE6, 0xF5, 0x52, 0xDE, 0xDF, 0x17, 0x5E,
0x2E, 0xAC, 0x9B, 0x00, 0xCE, 0x06, 0x6C, 0xFF,
0x33, 0xB1, 0xFD, 0x75, 0x7A, 0xA1, 0x01, 0xDC,
0x5F, 0x21, 0x21, 0x4C, 0x5D, 0x21, 0x26, 0x99,
0xCB, 0x36, 0xFE, 0xD1, 0xB6, 0xD1, 0x53, 0xFB,
0x6F, 0x9A, 0x36, 0xBF, 0x49, 0xCF, 0x83, 0x22,
0xDF, 0x04, 0x70, 0x3C, 0xB1, 0xFC, 0xC4, 0x16,
0x7B, 0x66, 0xCD, 0x8D, 0x12, 0xCE, 0x15, 0x72,
0x16, 0x22, 0xF4, 0xE0, 0xB5, 0xDA, 0x11, 0x03,
0xFA, 0xC6, 0xB2, 0x82, 0x17, 0x58, 0xF1, 0x01,
0x18, 0x5B, 0xFD, 0x92, 0x36, 0xDF, 0x39, 0xA9,
0xA5, 0xA5, 0x8E, 0x41, 0xD8, 0x4B, 0x56, 0x1F,
0xCF, 0x1D, 0x9A, 0x85, 0xE8, 0xAD, 0x7F, 0x6C,
0x7B, 0x1A, 0x6A, 0xFF, 0x87, 0xFF, 0xB6, 0xFC,
0x1E, 0x1D, 0xC5,
0x96, 0x9F, 0x1B, 0x53, 0xFE, 0x03, 0x49, 0xED,
0x81, 0xAF, 0x31, 0x1A, 0x8D, 0x5A, 0x4C, 0xF6,
0x53, 0x08, 0x0B, 0x5F, 0xA3, 0xEA, 0x3B, 0x8C,
0x68, 0xFA, 0x64, 0x94, 0xF6, 0x7C, 0xE1, 0x93,
0x96, 0xF7, 0x64, 0x62, 0xD4, 0xD8, 0xAD, 0x7E,
0x6A, 0xB0, 0x0C, 0xE5, 0xCA, 0xBB, 0xE9, 0x3C,
0x5C, 0x1A, 0x5E, 0x5C, 0xB4, 0xAF, 0x14, 0xBB,
0x37, 0x57, 0x93, 0x61, 0x15, 0x4F, 0xB3, 0x70,
0x7B, 0x16, 0x19, 0xE8, 0x4B, 0x47, 0x60, 0xE3,
0x88, 0xF7, 0x88, 0x3D, 0x4F, 0xB8, 0x80, 0x14,
0x0A, 0x27, 0x11, 0xEB, 0xE1, 0xDD, 0xD4, 0x9D,
0x10, 0x22, 0xBD, 0x81, 0x9D, 0x36, 0x8E, 0xFF,
0xF8, 0x07, 0xB7, 0x5E, 0x1A, 0x29, 0x85, 0xBB,
0x5D, 0x30, 0xD4, 0x42, 0xBE, 0x25, 0xD3, 0xCD,
0x77, 0x7F, 0x14, 0x15, 0xEC, 0x33, 0x92, 0x56,
0x5C, 0xC2, 0xDA, 0xD9, 0xD8, 0xEF, 0xFB, 0x28,
0xED, 0xE5, 0x33, 0x6A, 0xAD, 0xA3, 0x27, 0x74,
0xF4, 0x5D, 0xBD, 0x13, 0x62, 0x43, 0xA1, 0x85,
0x92, 0xBB, 0x90, 0x7D, 0x13, 0xE8, 0xC4, 0x9D,
0x52, 0x38, 0x5E, 0xF9, 0xBF, 0x24, 0x1A, 0x47,
0xA1, 0x88, 0x70, 0x25, 0x06, 0x6E, 0x90, 0xD2,
0x54, 0xA2, 0x27, 0x29, 0xD2, 0x7E, 0x43, 0xB4,
0x4B, 0xB1, 0x44, 0x8E, 0xA4, 0xD0, 0x77, 0xBB,
0xE7, 0xB2, 0xB7, 0x35, 0xCA, 0xCF, 0xFD, 0xF9,
0x82, 0xF9, 0x42, 0x11,
0x33, 0x10, 0x0E, 0xBA, 0xD9, 0x56, 0xE8, 0xDF,
0xB5, 0xDB, 0x9C, 0xB8, 0x54, 0x0A, 0x7E, 0x1B,
0x9A, 0xB6, 0x8F, 0xBF, 0x1B, 0x0F, 0x15, 0xA1,
0x63, 0x81, 0x7F, 0xDC, 0x76, 0x23, 0x7B, 0xFF,
0x48, 0xCA, 0xE4, 0x3C, 0x5D, 0xA0, 0x92, 0xA2,
0x10, 0x26, 0x12, 0x85, 0x31, 0xFC, 0x36, 0xCC,
0xD5, 0x43, 0x60, 0xC3, 0xF8, 0x57, 0x35, 0x0C,
0x60, 0x42, 0xD5, 0xC3, 0xEB, 0x1A, 0xDF, 0xDD,
0x30, 0x9A, 0x09, 0xAB, 0xF7, 0xEB, 0xAF, 0xFF,
0x5B, 0x3D, 0x41, 0x6D, 0x6C, 0x89, 0x39, 0xBC,
0x33, 0xB5, 0x2E, 0x17, 0xC4, 0xD5, 0xE0, 0xBE,
0xD1, 0x85, 0x85, 0x72, 0x40, 0x58, 0x78, 0x91,
0x46, 0x73, 0xFC, 0xDF, 0x25, 0x40, 0x9A, 0x69,
0x7E, 0x7D, 0xEB, 0xE4, 0x8B, 0xC5, 0xBC, 0x3C,
0x45, 0x14, 0xA8, 0x8A, 0x56, 0xE2, 0x83, 0x26,
0xB4, 0xD8, 0xAC, 0xA8, 0xD2, 0x97, 0x57, 0xC0,
0xBB, 0x1B, 0x25, 0xDB, 0x36, 0xA3, 0x65, 0x26,
0x6F, 0xB6, 0xC3, 0x94, 0xBC, 0xCA, 0x15, 0x92,
0xBC, 0xCD, 0xE6, 0x6F, 0x58, 0x7E, 0xB4, 0x68,
0xC8, 0xAF, 0xF5, 0xAD, 0x65, 0x7A, 0xBD, 0xF9,
0x54, 0x63, 0xAB, 0x66, 0x0E, 0x89, 0x66, 0x93,
0xEF, 0x9D, 0x68, 0x4F, 0x1E, 0x3D, 0x55, 0xAA,
0x7F, 0x7C, 0xE8, 0x20, 0x9D, 0xB6, 0xA3, 0x78,
0x59, 0xA2, 0x3E, 0x37, 0xC9, 0x68, 0xD9, 0xD7,
0x5C, 0xA7, 0x4D, 0x4E, 0x39,
0xB0, 0x84, 0x98, 0x23, 0xF4, 0x55, 0x8B, 0x12,
0xFE, 0x21, 0xCB, 0xD8, 0x88, 0x6B, 0x42, 0xA1,
0x35, 0xD4, 0x46, 0x5C, 0x4E, 0x0D, 0x36, 0x6C,
0x83, 0xA9, 0x4C, 0x12, 0x2D, 0x7F, 0xE6, 0x9F,
0xED, 0x05, 0x79, 0xEC, 0xD6, 0x0C, 0x6D, 0xFC,
0xB9, 0xA1, 0x69, 0x87, 0x6E, 0x49, 0x37, 0xCB,
0xC8, 0x24, 0x17, 0x95, 0x39, 0x8A, 0xFE, 0x03,
0xFF, 0x95, 0x10, 0xDC, 0x3F, 0xDF, 0x16, 0x40,
0x70, 0x24, 0x9C, 0x9E, 0x9B, 0x61, 0xF2, 0xB0,
0xD1, 0x93, 0x53, 0xFD, 0x44, 0x10, 0xD2, 0x2D,
0xE6, 0xD6, 0x90, 0x97, 0x25, 0xF5, 0xF0, 0x29,
0x10, 0xF4, 0xE4, 0xA8, 0x8B, 0xC0, 0xB0, 0xD5,
0x32, 0x03, 0x96, 0xD3, 0x92, 0x3E, 0x7A, 0x71,
0x03, 0xC2, 0xA9, 0x76, 0x3A, 0x4A, 0x4A, 0x04,
0x71, 0x86, 0x94, 0xED, 0xD0, 0x41, 0x16, 0x36,
0xD1, 0x38, 0x90, 0x46, 0xBB, 0xAA, 0x3F, 0xE6,
0x5F, 0x42, 0x14, 0x87, 0xFB, 0x60, 0x25, 0x07,
0xBB, 0xCC, 0x0D, 0xCB, 0xFF, 0xAD, 0xFE, 0xEC,
0xA1, 0x10, 0x56, 0x30, 0x30, 0xDF, 0xC4, 0xA5,
0x99, 0x96, 0xCB, 0xD1, 0x51, 0xE2, 0x77, 0xF1,
0x4F, 0x39, 0xDB, 0x06, 0x6A, 0xE3, 0x01, 0xC3,
0x02, 0x0C, 0x27, 0x82, 0x0B, 0x5A, 0x1E, 0x42,
0x4D, 0x7E, 0xF2, 0xB2, 0xAB, 0x70, 0x65, 0xCE,
0x4D, 0x44, 0x39, 0x4A, 0xDF, 0xB9, 0xAB, 0x8C,
0x14, 0x89, 0x9E, 0x9A, 0x26, 0xFC,
0xB1, 0x1B, 0xD2, 0x70, 0xE9, 0xA0, 0x11, 0x31,
0x6C, 0xF4, 0x64, 0x96, 0x93, 0xE5, 0x90, 0xC4,
0xFB, 0x8B, 0xEA, 0xAF, 0x27, 0x91, 0x47, 0x23,
0x3A, 0x12, 0xA2, 0x6C, 0x52, 0x8B, 0xF6, 0x2E,
0xAF, 0xA7, 0x81, 0x2B, 0xB8, 0x43, 0x4B, 0xEF,
0x35, 0x90, 0xBE, 0x1A, 0x6D, 0x8B, 0x8F, 0xD4,
0x71, 0x89, 0xE9, 0x94, 0x26, 0x82, 0x93, 0x09,
0xFB, 0xB8, 0xD1, 0xA1, 0x19, 0xDA, 0x94, 0x9A,
0xE3, 0x57, 0xD2, 0x66, 0x40, 0xD1, 0xBE, 0x49,
0x0A, 0x22, 0xE0, 0x35, 0x8B, 0x21, 0xDA, 0xCB,
0xF4, 0xED, 0xE6, 0xA2, 0x22, 0xF8, 0x5A, 0xFD,
0x45, 0x22, 0x53, 0xD6, 0xAA, 0x4B, 0xDE, 0x6C,
0x47, 0x07, 0x65, 0x72, 0x2C, 0x23, 0xB2, 0x31,
0xEE, 0x93, 0x14, 0x46, 0xDE, 0x9C, 0x51, 0x2A,
0x99, 0x42, 0x58, 0x11, 0x10, 0x57, 0xB6, 0x31,
0xC4, 0xFF, 0x74, 0xB8, 0x23, 0x36, 0x92, 0xF5,
0x75, 0x2E, 0x20, 0x49, 0x19, 0xE4, 0xC7, 0xFC,
0x4C, 0xC5, 0xA9, 0x2E, 0x58, 0xA1, 0x66, 0xA0,
0x9B, 0x00, 0x9B, 0xDC, 0x80, 0xBC, 0x78, 0xB4,
0xE7, 0xB0, 0xCE, 0x94, 0x5D, 0x0C, 0x70, 0x89,
0xFF, 0xC8, 0x13, 0x38, 0x30, 0xFB, 0x32, 0x4B,
0xD8, 0x05, 0xC3, 0x68, 0x3E, 0x89, 0x00, 0x1A,
0x61, 0x3B, 0xB0, 0x2A, 0xC4, 0xE9, 0x13, 0xFB,
0x80, 0xC3, 0xDD, 0x92, 0xE6, 0xB9, 0xBC, 0xAE,
0xE9, 0xBE, 0x4C, 0xE8, 0x2D, 0xC2, 0x9E,
0xA7, 0x9C, 0x5B, 0x54, 0x2B, 0x92, 0x1C, 0x5F,
0xCE, 0x37, 0xEB, 0x05, 0x76, 0x67, 0x39, 0xF4,
0x15, 0x2B, 0x89, 0x67, 0xDB, 0xC4, 0xB7, 0x36,
0xD3, 0x56, 0xE2, 0x9A, 0x25, 0xD6, 0x47, 0x52,
0xA5, 0xB5, 0x7D, 0x30, 0x25, 0xE4, 0x92, 0x39,
0x9C, 0xC0, 0xDB, 0x94, 0x03, 0x8D, 0x26, 0x57,
0x2E, 0xC6, 0x90, 0x88, 0x37, 0x62, 0xD4, 0x82,
0x0C, 0xD4, 0xDD, 0x7D, 0x88, 0xC1, 0xDA, 0xE8,
0xD8, 0x26, 0x8C, 0x58, 0x69, 0x87, 0xDB, 0x05,
0xDB, 0x97, 0x4F, 0x0A, 0x94, 0xF0, 0xA7, 0x0A,
0x13, 0x4A, 0x25, 0x69, 0xAC, 0x34, 0x7D, 0xB6,
0x15, 0x5A, 0x14, 0x1E, 0x94, 0x42, 0xB1, 0x02,
0x25, 0xD5, 0xBC, 0x9B, 0x15, 0x26, 0xD4, 0x74,
0x10, 0x85, 0x8A, 0x1A, 0x24, 0x65, 0xAB, 0x3C,
0xBD, 0xB8, 0x43, 0x27, 0x6A, 0x83, 0x93, 0x46,
0x39, 0x38, 0x30, 0xF2, 0xC8, 0x89, 0x58, 0xD7,
0x97, 0x02, 0x8F, 0x6C, 0x10, 0xD3, 0xAE, 0x17,
0x60, 0xF2, 0xE7, 0x43, 0xDD, 0x8A, 0x5D, 0xB3,
0x23, 0xAF, 0x08, 0x64, 0x50, 0xA3, 0x78, 0xC9,
0xC7, 0x83, 0xB0, 0x30, 0x4D, 0x53, 0xB9, 0xBD,
0x97, 0x3C, 0x65, 0x02, 0x3C, 0x49, 0xAC, 0xA4,
0x5D, 0x4C, 0x22, 0x12, 0x32, 0x03, 0x82, 0x1F,
0x07, 0x87, 0xFD, 0xF5, 0xDC, 0xA8, 0xFE, 0x8A,
0x35, 0x3C, 0xAC, 0xEF, 0x81, 0x7F, 0x74, 0x9B,
0x43, 0xA4, 0xDF, 0x8E, 0x4B, 0x8A, 0x4C, 0xF9,
0x26, 0x82, 0x9C, 0x64, 0x01, 0xB8, 0x57, 0x0C,
0x22, 0x95, 0x20, 0x5A, 0xF4, 0x29, 0xFD, 0xFD,
0x80, 0xD4, 0xF7, 0xB9, 0xE1, 0xF6, 0x2D, 0xDA,
0x7F, 0x40, 0x53, 0x90, 0xF4, 0x49, 0x08, 0x11,
0x0B, 0x21, 0x19, 0x9D, 0x3D, 0x98, 0xE8, 0x4D,
0xEE, 0x58, 0xCB, 0x20, 0x07, 0xEA, 0xEF, 0x86,
0x91, 0x81, 0xF5, 0x40, 0x73, 0xFB, 0xCF, 0x54,
0x18, 0x05, 0x23, 0x1D, 0x51, 0x21, 0x8B, 0x16,
0xC6, 0xFE, 0x94, 0x5F, 0xED, 0xC6, 0x0B, 0x30,
0x30, 0x3A, 0xEA, 0x8F, 0xE8, 0x49, 0x5D, 0x9A,
0xF2, 0xDB, 0x7A, 0x3E, 0x8D, 0xAC, 0x3E, 0xCF,
0xB5, 0x78, 0x31, 0x45, 0xC0, 0x3E, 0x8E, 0x8A,
0x6A, 0xDD, 0x3F, 0x9B, 0xD6, 0xDC, 0xFB, 0x0E,
0x1D, 0xA2, 0xF6, 0xDD, 0x8C, 0x9D, 0xCD, 0xD7,
0x57, 0x54, 0xB9, 0x8A, 0xC6, 0x52, 0xBD, 0x76,
0xE5, 0x3B, 0x79, 0xCD, 0x51, 0x64, 0x33, 0x42,
0xB6, 0xF8, 0xA8, 0x5D, 0xFF, 0x74, 0xE6, 0x26,
0x66, 0xE1, 0x8C, 0xD4, 0x42, 0xE4, 0xBA, 0x82,
0x40, 0x28, 0xE8, 0x42, 0xB6, 0x84, 0xEF, 0xB9,
0x46, 0xCB, 0x73, 0xA4, 0xFF, 0x56, 0x46, 0x21,
0x8F, 0x95, 0xD8, 0x9B, 0xE5, 0xFB, 0xC2, 0xF1,
0x8F, 0x10, 0x19, 0x88, 0xFC, 0x74, 0xA2, 0x69,
0xCE, 0xC1, 0xF2, 0x04, 0x29, 0x85, 0x78, 0x31,
0x6F, 0x97, 0x82, 0x44, 0x9C, 0x11, 0xB6, 0x28,
0x2D, 0x1A, 0xFB, 0xF8, 0x17, 0xBE, 0x51, 0x11,
0xBD,
0xD1, 0xFE, 0xC4, 0xDE, 0x12, 0x1A, 0x63, 0x36,
0x0A, 0x08, 0x8A, 0xFF, 0xFD, 0xAF, 0x0A, 0x2E,
0xB4, 0x0E, 0xB9, 0x2A, 0x5A, 0x2A, 0x0B, 0x3B,
0x46, 0x32, 0xDE, 0xA2, 0xC7, 0x07, 0x73, 0x42,
0xBE, 0x62, 0x01, 0xF1, 0xB3, 0xF0, 0x62, 0x67,
0x8C, 0x99, 0x53, 0x0B, 0x6C, 0xD3, 0x40, 0xEE,
0x8E, 0xE1, 0x97, 0xD1, 0xBE, 0x19, 0xCD, 0xDE,
0x75, 0x37, 0x6C, 0xE8, 0x21, 0xD7, 0x6E, 0x7A,
0x9D, 0xB5, 0xEA, 0xC0, 0xD9, 0x69, 0xB1, 0xBF,
0xE2, 0xEF, 0xF0, 0xBD, 0x01, 0xFB, 0x57, 0xDA,
0x8F, 0x62, 0x36, 0x46, 0x10, 0x45, 0xB8, 0xBB,
0xD4, 0xC6, 0xF6, 0x5C, 0x29, 0x9C, 0x7B, 0x53,
0xF7, 0x0A, 0x9C, 0xDB, 0x37, 0xB3, 0x0D, 0xFC,
0x3A, 0x3F, 0x6A, 0xE9, 0xB3, 0xEB, 0x24, 0x34,
0x3A, 0x3C, 0x62, 0x34, 0xEB, 0x7F, 0xD8, 0xC9,
0x76, 0x65, 0x95, 0x03, 0xC4, 0x5B, 0x90, 0x47,
0x36, 0x70, 0x33, 0x7D, 0x4C, 0x64, 0xA1, 0xCD,
0xA1, 0xDE, 0xB3, 0x83, 0x2A, 0x64, 0x12, 0xBC,
0xB9, 0xAC, 0x8D, 0x66, 0xF8, 0x63, 0xBE, 0x84,
0x2C, 0xA7, 0x8A, 0xB4, 0x5A, 0xB6, 0xCC, 0x31,
0x8A, 0x4E, 0xD0, 0x37, 0x08, 0x9F, 0xFE, 0xEC,
0xFE, 0xC5, 0x9C, 0x77, 0x19, 0x61, 0x84, 0x37,
0x2F, 0xA5, 0xA0, 0xF3, 0x7D, 0xD9, 0xDA, 0xA6,
0x26, 0x1A, 0xE2, 0x98, 0x25, 0x26, 0xBD, 0xDB,
0x4C, 0x2D, 0xF9, 0xB9, 0xD3, 0x6E, 0x74, 0x5E,
0x9F, 0x1C,
0x85, 0xBB, 0x36, 0x04, 0x3F, 0x4C, 0x21, 0x84,
0x25, 0x52, 0xC2, 0x0B, 0x29, 0xA9, 0x69, 0x50,
0x5A, 0x19, 0x72, 0xAA, 0xA9, 0x4C, 0x89, 0xA9,
0xDF, 0xA7, 0x72, 0x97, 0x96, 0xDE, 0xB5, 0x95,
0xFF, 0xF6, 0x5F, 0xFC, 0xF7, 0x0D, 0xE9, 0x61,
0x19, 0x5C, 0xC8, 0x0C, 0xCE, 0xD6, 0xC2, 0xB5,
0x58, 0x62, 0x32, 0x62, 0xD2, 0x38, 0x4F, 0xA4,
0x79, 0xFA, 0xAD, 0x37, 0x23, 0x80, 0xA8, 0xBF,
0xD3, 0xE9, 0x23, 0x32, 0x4C, 0xD0, 0x66, 0xE1,
0x24, 0x4F, 0x0B, 0x28, 0xCD, 0xB7, 0x9C, 0x7C,
0x5A, 0x7B, 0xF6, 0xB0, 0xF4, 0x58, 0xCB, 0xDC,
0x88, 0xC8, 0x10, 0x3B, 0x08, 0x1A, 0xB6, 0x81,
0x10, 0x8A, 0xCC, 0x14, 0xB9, 0xA8, 0x79, 0x09,
0x80, 0x98, 0x19, 0x33, 0x3E, 0x80, 0x2D, 0x82,
0x4D, 0x18, 0x0F, 0x6C, 0x17, 0xC1, 0x5C, 0x5C,
0x59, 0xD5, 0x27, 0x4A, 0x84, 0xE6, 0x1B, 0x13,
0x8B, 0x28, 0xB3, 0x47, 0x70, 0x97, 0x48, 0xA6,
0x53, 0x59, 0x24, 0x5B, 0xDB, 0xBA, 0x3F, 0xC6,
0x59, 0xBF, 0xAD, 0x7A, 0x2B, 0xF7, 0xAB, 0xF9,
0xA2, 0x8C, 0x3A, 0x7E, 0x9A, 0xC7, 0x18, 0xD7,
0xE7, 0x9E, 0x62, 0x7A, 0x36, 0x96, 0x8A, 0x2C,
0xDE, 0x26, 0x8B, 0x08, 0xB2, 0xE0, 0x26, 0x84,
0xD3, 0xD4, 0xC7, 0x18, 0xCF, 0xBD, 0x6A, 0x97,
0x45, 0x22, 0xE9, 0x6D, 0x3A, 0xD8, 0xA5, 0x60,
0x6D, 0x7B, 0x5D, 0x27, 0xF8, 0x77, 0x0C, 0x9F,
0x21, 0xBA, 0xD5,
0xB3, 0x81, 0xFD, 0x78, 0xA3, 0x15, 0x07, 0xFE,
0xD0, 0x0A, 0xB1, 0xCD, 0x44, 0x19, 0xC9, 0xA7,
0xE2, 0x87, 0xCF, 0x88, 0xFA, 0x40, 0x56, 0xD1,
0xC0, 0xCE, 0xD8, 0xE1, 0x31, 0xFE, 0xF8, 0x64,
0x6C, 0x25, 0xA3, 0x58, 0x73, 0xC6, 0x06, 0x44,
0x47, 0x9C, 0x66, 0x7F, 0x89, 0x15, 0x2E, 0x15,
0xDB, 0x44, 0x2B, 0x36, 0x5A, 0x0F, 0xAC, 0xAC,
0x41, 0x5D, 0x8D, 0xF6, 0x82, 0x61, 0xA5, 0x5F,
0x04, 0x2E, 0xE2, 0x86, 0x4F, 0x98, 0x40, 0xAA,
0xD5, 0xD6, 0x08, 0x02, 0xB7, 0x4F, 0x73, 0xF5,
0xEB, 0xDC, 0x31, 0x51, 0x87, 0x77, 0xAB, 0x3B,
0x6D, 0xCD, 0x84, 0x7C, 0xC9, 0xDE, 0x3B, 0x18,
0x0E, 0xE3, 0x31, 0x10, 0xD7, 0xC7, 0x1B, 0xED,
0xC4, 0x44, 0x38, 0x07, 0x9D, 0x8D, 0xA9, 0x6A,
0xE7, 0x3B, 0x15, 0x9C, 0xC6, 0x08, 0xE9, 0x78,
0x82, 0xDB, 0xD1, 0x6E, 0xD1, 0x6A, 0xB9, 0x19,
0xF3, 0x9B, 0x00, 0xD9, 0x1A, 0x1A, 0x6C, 0x62,
0xC2, 0x4D, 0x03, 0xC3, 0xF1, 0x65, 0xE8, 0x2F,
0xE6, 0xD2, 0x5B, 0x07, 0x88, 0xFB, 0xC5, 0x27,
0x41, 0xC3, 0xF6, 0xC6, 0xC2, 0xB7, 0x36, 0x44,
0xC6, 0x94, 0xD7, 0xCD, 0x65, 0x20, 0xBA, 0x75,
0xF6, 0x27, 0xE7, 0xAC, 0xFA, 0xA4, 0x9D, 0x1F,
0xC6, 0x08, 0xDF, 0x6E, 0xD0, 0x61, 0x6E, 0x8B,
0x29, 0x92, 0xA8, 0x49, 0xE5, 0xE7, 0x3F, 0x3D,
0x63, 0x49, 0x27, 0x36, 0xB8, 0xA6, 0x23, 0xBA,
0xA4, 0xE2, 0x05, 0x07,
0xA8, 0xBC, 0x1F, 0x2A, 0x63, 0x31, 0xC5, 0x24,
0xCA, 0xA0, 0x6E, 0x5B, 0x7E, 0xBF, 0xAA, 0x29,
0xBB, 0xB2, 0xA4, 0x7F, 0xF1, 0x25, 0x1A, 0xCF,
0x4B, 0xA3, 0x43, 0xAF, 0x4A, 0x2A, 0x79, 0x49,
0x7B, 0xD1, 0xAE, 0xE5, 0x13, 0x3B, 0xF2, 0x36,
0x83, 0xD2, 0x57, 0xE9, 0xFD, 0x7E, 0x4D, 0x01,
0x3D, 0x15, 0x72, 0xAF, 0x8C, 0x9C, 0xDB, 0xFD,
0xC3, 0xA2, 0xF8, 0xF6, 0x8C, 0x55, 0x49, 0xB9,
0xA3, 0xC1, 0xF9, 0x42, 0xB6, 0x98, 0xF4, 0x33,
0x6C, 0x14, 0xD3, 0x67, 0x44, 0x84, 0x7C, 0xED,
0x41, 0x61, 0xC7, 0xD1, 0xEB, 0x3D, 0x68, 0x26,
0xBA, 0x5B, 0x74, 0xB3, 0x12, 0xBF, 0xC9, 0x6F,
0x5D, 0xB4, 0x7D, 0x33, 0x19, 0xA2, 0xB7, 0x89,
0x69, 0x41, 0xE0, 0x63, 0x39, 0xDF, 0x11, 0xEE,
0x89, 0xBD, 0x82, 0x1B, 0xBC, 0xD4, 0x55, 0x7D,
0xBA, 0x27, 0xB6, 0x29, 0x20, 0xB6, 0xAF, 0x3F,
0x3C, 0x66, 0xF5, 0x82, 0x7A, 0xA4, 0xBA, 0x02,
0xCF, 0xC8, 0x70, 0xD1, 0x7B, 0x90, 0x1B, 0x58,
0x9B, 0x05, 0x66, 0x0E, 0xA9, 0xF8, 0x07, 0x52,
0x3A, 0xCB, 0x4C, 0x58, 0xBD, 0xD6, 0x53, 0xF7,
0x6B, 0x9C, 0x1D, 0x05, 0x4F, 0x4E, 0xCB, 0x14,
0xA7, 0x5B, 0x33, 0xB9, 0x83, 0x4A, 0x93, 0xEB,
0x73, 0xAB, 0xCF, 0x0E, 0x4E, 0xF2, 0x31, 0x2F,
0xED, 0x93, 0xFA, 0xDC, 0x44, 0xF5, 0xCB, 0x30,
0x9A, 0xF9, 0x41, 0xC6, 0x29, 0x03, 0x51, 0x61,
0x42, 0x42, 0xCA, 0x22, 0x48,
0x81, 0xB2, 0xBE, 0xEC, 0x28, 0x75, 0xA6, 0x88,
0x71, 0x66, 0x44, 0xF2, 0xB9, 0xA4, 0x2B, 0x7E,
0x34, 0x9F, 0xBB, 0x1A, 0xA0, 0x8E, 0xB0, 0x58,
0x6B, 0x01, 0xE0, 0x74, 0xBE, 0x9B, 0x73, 0xDB,
0x57, 0x95, 0x28, 0xBF, 0xD8, 0x27, 0x9E, 0x42,
0x01, 0x43, 0x73, 0x08, 0xF9, 0xE8, 0xFF, 0xC2,
0x1E, 0xEA, 0x30, 0xA1, 0xD4, 0x35, 0xBD, 0x18,
0xDB, 0x4A, 0xFD, 0x99, 0x28, 0xEA, 0x9B, 0xAC,
0x3C, 0xE4, 0x7B, 0x10, 0x72, 0x0D, 0x35, 0xFD,
0x40, 0xA0, 0xF3, 0xE4, 0xB5, 0xA5, 0xDB, 0xAB,
0x8E, 0x23, 0x69, 0xF5, 0xF9, 0xB8, 0x6B, 0x00,
0x60, 0x29, 0xAA, 0x74, 0xCA, 0x36, 0xE4, 0xD4,
0x43, 0xCC, 0xE0, 0xB3, 0xF7, 0x74, 0xF1, 0x69,
0xF1, 0x2B, 0x9D, 0x03, 0x6E, 0x7B, 0x27, 0x3F,
0x3B, 0xB2, 0x41, 0x04, 0x17, 0x5A, 0x59, 0xAD,
0xAB, 0x0B, 0x50, 0x5A, 0x69, 0x55, 0xAE, 0xB8,
0x4E, 0xCF, 0x35, 0x96, 0xAB, 0xD7, 0xC0, 0xEB,
0xED, 0x12, 0xF4, 0x69, 0xEE, 0xBF, 0x62, 0xD9,
0xBE, 0xF5, 0x19, 0xC8, 0xEF, 0xF0, 0x54, 0xCF,
0x8C, 0x7B, 0xD1, 0xF6, 0x9A, 0xE8, 0xF8, 0x19,
0x7E, 0xE6, 0x87, 0x40, 0x39, 0x95, 0x54, 0x2F,
0xAA, 0xED, 0xF4, 0x0D, 0x41, 0x3B, 0xE8, 0x37,
0xDA, 0xDF, 0x6D, 0x2B, 0xE5, 0xED, 0xBC, 0xBA,
0x49, 0x38, 0x6B, 0x86, 0xDC, 0xD0, 0xC7, 0x59,
0xB2, 0x2F, 0xC4, 0x00, 0x24, 0xFF, 0x2C, 0x29,
0x91, 0x89, 0xCE, 0xB5, 0xA3, 0x01,
0xF7, 0xF0, 0xD8, 0xBE, 0x57, 0x34, 0x32, 0x02,
0xF2, 0x39, 0x72, 0x4A, 0x04, 0xE0, 0xEB, 0x89,
0x66, 0x53, 0x71, 0x20, 0x53, 0xE8, 0x29, 0x17,
0x09, 0xD2, 0xD8, 0x31, 0x15, 0x9F, 0x66, 0x8F,
0xD4, 0x61, 0xB5, 0x0A, 0xF3, 0x7C, 0xB8, 0xE5,
0xCD, 0x13, 0xC5, 0xA6, 0x0D, 0x26, 0x81, 0xDE,
0x1E, 0x05, 0x28, 0x7D, 0x1C, 0xCB, 0xAC, 0x14,
0x51, 0x06, 0xCB, 0x44, 0x92, 0xD5, 0x48, 0x04,
0xA0, 0x10, 0x45, 0xAD, 0x26, 0xD3, 0xDB, 0xE5,
0xE3, 0xAF, 0x05, 0x10, 0x8B, 0x2A, 0x99, 0xB5,
0x4D, 0xE9, 0x88, 0xDF, 0x88, 0x1A, 0xD1, 0x13,
0x54, 0x5F, 0x8A, 0x25, 0x4F, 0x5A, 0xA9, 0x27,
0x9D, 0xD4, 0x7F, 0x8B, 0x13, 0xB7, 0xCF, 0x37,
0x36, 0x69, 0x65, 0x24, 0x36, 0x57, 0x39, 0x21,
0x14, 0xF0, 0x70, 0x1E, 0x40, 0xCB, 0x33, 0x78,
0x45, 0x1F, 0x9F, 0x90, 0x4A, 0xD4, 0xBF, 0xF8,
0x7C, 0x92, 0x16, 0x1A, 0xEE, 0xEA, 0xD5, 0x4A,
0x0C, 0xE4, 0x19, 0x13, 0xA9, 0x0F, 0xE2, 0x0C,
0x31, 0x08, 0xE1, 0x83, 0x66, 0x5D, 0x70, 0x02,
0xF7, 0x22, 0x2B, 0x19, 0xB6, 0xD0, 0xF9, 0x98,
0xC5, 0x4F, 0xEC, 0x6C, 0x92, 0x23, 0x37, 0x55,
0xA3, 0xAD, 0xA2, 0xD3, 0xFE, 0xA6, 0x11, 0xC8,
0x9A, 0x54, 0x19, 0xE4, 0x03, 0x4A, 0x97, 0xE5,
0xB3, 0x00, 0x4A, 0xD7, 0x8B, 0x03, 0x1E, 0xE8,
0x48, 0x4B, 0xB9, 0x43, 0x8C, 0x80, 0xC4, 0x19,
0x6C, 0xE8, 0xD7, 0xD4, 0xA3, 0xD7, 0x05,
0x50, 0x04, 0xD3, 0xA5, 0xC7, 0x66, 0x20, 0x16,
0x94, 0x65, 0xAA, 0xA8, 0x38, 0xC6, 0x4B, 0x63,
0x5E, 0xB1, 0x7A, 0xED, 0x51, 0x1C, 0xB6, 0xC0,
0xF1, 0xF7, 0x60, 0xF6, 0x4E, 0xA6, 0x00, 0x6B,
0x8F, 0x7B, 0x73, 0xDB, 0x8A, 0xBB, 0x19, 0xDE,
0x12, 0x22, 0xBE, 0xC7, 0x14, 0x93, 0x10, 0x78,
0x65, 0x5B, 0x13, 0x9B, 0x8C, 0xC7, 0xF8, 0xAB,
0x41, 0x67, 0x1F, 0xD9, 0x94, 0xB4, 0x2E, 0xEA,
0xD8, 0x29, 0x00, 0x26, 0x16, 0x25, 0xA9, 0xA1,
0xB0, 0x04, 0x9D, 0x6C, 0xCA, 0xF0, 0xDA, 0xA5,
0xA4, 0x1F, 0xA8, 0x4E, 0xFA, 0x30, 0x8E, 0x05,
0x4D, 0x88, 0x70, 0x23, 0x27, 0x01, 0x03, 0x17,
0x11, 0x05, 0x5C, 0xCB, 0x74, 0xBF, 0x20, 0x81,
0x5F, 0xC3, 0x92, 0xBD, 0xBD, 0xA3, 0xD1, 0xA4,
0x77, 0xE0, 0x6D, 0x97, 0x12, 0x46, 0x21, 0x42,
0xF7, 0xD3, 0xA7, 0xA0, 0x48, 0x6B, 0xC9, 0x97,
0x9A, 0xBE, 0xF9, 0xBD, 0x9D, 0x97, 0xF5, 0xB7,
0x58, 0x5E, 0xF4, 0x3B, 0x8C, 0x27, 0x83, 0xBC,
0xDF, 0x66, 0xE5, 0xC3, 0x8C, 0x2C, 0xE5, 0xAE,
0xBA, 0x34, 0x0A, 0xE5, 0x47, 0x04, 0x5E, 0x7F,
0x60, 0x41, 0x33, 0x1C, 0xA9, 0xA2, 0x51, 0x26,
0x5E, 0x43, 0x62, 0xCF, 0x7E, 0xA9, 0x9E, 0x60,
0x80, 0xCD, 0xE5, 0xE5, 0x0A, 0xB3, 0xF0, 0x8F,
0x2F, 0xCC, 0xE7, 0x70, 0x9F, 0x50, 0xE7, 0x9E,
0x17, 0xBB, 0x0B, 0xD8, 0x2B, 0xA1, 0xB0, 0x81,
0xAE, 0x9D, 0x68, 0x6A, 0x1B, 0x37, 0xBA, 0x08,
0x20, 0x43, 0x50, 0x8B, 0x58, 0xFB, 0x49, 0x9D,
0x17, 0x97, 0x72, 0x0A, 0x36, 0xF0, 0x1A, 0x01,
0xFD, 0xF9, 0xFC, 0x19, 0xC8, 0x04, 0x2F, 0x33,
0x9D, 0xCB, 0x26, 0xF0, 0x4B, 0xBB, 0xE0, 0xF8,
0x33, 0x04, 0x39, 0x78, 0xA8, 0xFE, 0x88, 0xE2,
0x13, 0x47, 0x87, 0x95, 0x10, 0x98, 0x2F, 0x65,
0x0F, 0xC7, 0xDB, 0xD6, 0x85, 0x7E, 0x28, 0x0B,
0x5C, 0x4F, 0x2F, 0xAB, 0x08, 0xD5, 0x0B, 0x0F,
0x38, 0xFB, 0xC2, 0x4F, 0x5F, 0x42, 0xA7, 0x11,
0x6E, 0x45, 0x00, 0x69, 0x4E, 0x33, 0x74, 0x6B,
0x4F, 0x2E, 0xBB, 0xD0, 0x5B, 0x94, 0x81, 0x50,
0xAE, 0xCD, 0x27, 0xC0, 0x15, 0x9C, 0xA0, 0x14,
0x9A, 0x49, 0x72, 0x63, 0xDD, 0xF7, 0x94, 0xEE,
0xFB, 0x23, 0x04, 0x82, 0x88, 0xFA, 0x13, 0x58,
0x56, 0x54, 0x77, 0x26, 0x99, 0x6A, 0xBD, 0x1F,
0xC8, 0xD9, 0x6B, 0xE9, 0xA2, 0x9E, 0xCB, 0x65,
0x24, 0x24, 0x03, 0x8F, 0x7C, 0x69, 0xF1, 0x32,
0x66, 0xA8, 0xE6, 0x18, 0xE5, 0xA7, 0x1C, 0x42,
0xFA, 0xF9, 0xD3, 0x4A, 0x04, 0xEE, 0x53, 0x49,
0xD0, 0x67, 0xBB, 0xAC, 0xB7, 0xD0, 0x16, 0x3C,
0x0A, 0xAB, 0x44, 0xE9, 0xCF, 0x8C, 0xC7, 0xFE,
0x28, 0x0D, 0x3F, 0xC2, 0x0D, 0xC9, 0x13, 0x34,
0x23, 0xF4, 0xA9, 0x3E, 0x29, 0xDF, 0x6E, 0xD0,
0xB2, 0xE9, 0x59, 0x98, 0x97, 0xCD, 0x5D, 0xB9,
0xF7, 0x94, 0xC0, 0x8D, 0x31, 0xB8, 0x38, 0x3D,
0x2D, 0x54, 0x3E, 0x6E, 0x63, 0xBB, 0x2A, 0x4A,
0x33,
0x33, 0x37, 0xA3, 0xB3, 0x5C, 0x4E, 0xF6, 0x5E,
0xBE, 0xC5, 0x4D, 0x8B, 0xC8, 0x3A, 0x73, 0x11,
0x14, 0x9C, 0xA0, 0x1F, 0x19, 0x2E, 0xDE, 0x9A,
0x32, 0xDA, 0xC5, 0x86, 0x82, 0xE9, 0x52, 0x5D,
0xE4, 0xDF, 0xF7, 0xFA, 0x84, 0xD2, 0x2F, 0x97,
0x2D, 0xBA, 0xCF, 0x8A, 0x4F, 0x18, 0xC2, 0x66,
0x00, 0xDC, 0x4B, 0x1F, 0x3C, 0x40, 0x1D, 0x12,
0x5C, 0x12, 0x7A, 0xD0, 0xA7, 0x63, 0xE1, 0x4B,
0x71, 0x8A, 0xAE, 0x78, 0x86, 0xDB, 0x7E, 0xAD,
0x82, 0xF6, 0x78, 0x97, 0x33, 0xFF, 0xDD, 0x41,
0x45, 0x8F, 0x13, 0x4C, 0x41, 0x46, 0x1D, 0x70,
0xF2, 0xCA, 0xB8, 0x97, 0x8B, 0x89, 0x0F, 0x13,
0xD1, 0xAE, 0xF8, 0xC0, 0x6C, 0xC5, 0x06, 0xF4,
0xCB, 0x0A, 0xC0, 0x90, 0xD9, 0x6A, 0x11, 0xDC,
0x39, 0xBB, 0x28, 0x3A, 0x68, 0xB0, 0x01, 0x28,
0xDD, 0xFC, 0x6C, 0xA8, 0x9F, 0x7B, 0x49, 0x3C,
0xC0, 0xCE, 0x46, 0x34, 0xE7, 0x77, 0x03, 0x4A,
0xDD, 0x92, 0x7C, 0xF7, 0xD0, 0x8B, 0x24, 0x9B,
0x94, 0x23, 0xE7, 0x3A, 0x27, 0xFD, 0x9E, 0x8A,
0x2F, 0x90, 0x51, 0x83, 0xCA, 0x60, 0xCA, 0x77,
0x2D, 0x8C, 0x7D, 0xAA, 0x62, 0x4F, 0xDC, 0x87,
0x67, 0xAD, 0x78, 0x18, 0xBF, 0x8A, 0xCB, 0x5B,
0x48, 0x7D, 0x21, 0xF7, 0x15, 0x8C, 0x09, 0xC0,
0x8C, 0x82, 0x45, 0xA1, 0xEF, 0x4F, 0xFD, 0x7D,
0x7F, 0x56, 0x65, 0x5B, 0x94, 0xDC, 0xF6, 0x0E,
0x9D, 0xBF, 0xC3, 0xF3, 0xDE, 0x09, 0xF6, 0x5B,
0xA0, 0x48,
0x73, 0xEA, 0xF4, 0xCA, 0x05, 0x5C, 0x05, 0x1A,
0x94, 0xAE, 0x2F, 0xEF, 0xAB, 0xF1, 0xDF, 0x1D,
0x11, 0x38, 0xFC, 0x06, 0x87, 0x27, 0xA4, 0xE9,
0xFC, 0xD7, 0xBB, 0xCB, 0x2B, 0x98, 0x78, 0xDE,
0x7B, 0x40, 0x5F, 0xA1, 0xBF, 0xCF, 0xF2, 0xF7,
0x29, 0x1A, 0x72, 0x47, 0x7B, 0x86, 0xC8, 0x67,
0x9C, 0xCE, 0x90, 0x85, 0xC6, 0xA2, 0x48, 0xB9,
0x01, 0xB3, 0x5F, 0x68, 0xF3, 0x43, 0x13, 0xE6,
0x20, 0x4B, 0xB2, 0xC2, 0xEC, 0xAF, 0x4C, 0x70,
0x80, 0xCD, 0x13, 0x11, 0x9C, 0x42, 0xFA, 0x51,
0x0A, 0x69, 0x88, 0x4C, 0xEC, 0x8E, 0xAB, 0x45,
0x16, 0x24, 0xB1, 0xA0, 0x1E, 0x7E, 0x54, 0x32,
0x2C, 0xD1, 0x5F, 0x94, 0x3A, 0x3B, 0xDC, 0x3E,
0xA6, 0x54, 0xCC, 0xB4, 0xFD, 0x5A, 0x51, 0x52,
0xFF, 0x06, 0xC0, 0x8B, 0xD5, 0x16, 0x06, 0xBF,
0x7B, 0x6D, 0x74, 0xA1, 0x47, 0x5E, 0x8D, 0x6C,
0xA3, 0x31, 0xC5, 0x1E, 0x1A, 0x55, 0x9B, 0x06,
0xBD, 0xA5, 0xF1, 0x2B, 0x4B, 0x32, 0x0B, 0x43,
0xDD, 0xCA, 0x33, 0xFD, 0x27, 0xBB, 0x16, 0xAD,
0xC5, 0xD9, 0x2A, 0x07, 0xE9, 0xAC, 0x6F, 0xCB,
0x3D, 0x17, 0xD2, 0xEC, 0x2F, 0x10, 0xA2, 0x0F,
0xCC, 0x23, 0xBE, 0x79, 0x02, 0xF3, 0x62, 0x2C,
0xE4, 0xE1, 0xFA, 0x7E, 0xCD, 0xDA, 0x2F, 0x19,
0x7A, 0xE4, 0xA0, 0x07, 0xF2, 0x69, 0x2E, 0x43,
0x92, 0x57, 0xEC, 0xA4, 0x70, 0x28, 0x5D, 0x63,
0x83, 0xAC, 0x3F, 0x5A, 0x3E, 0x7C, 0x20, 0xA7,
0x22, 0x4D, 0x9F,
0x94, 0x37, 0x7C, 0x1F, 0x68, 0x30, 0x1F, 0x83,
0x3B, 0xB7, 0xB0, 0x8D, 0x49, 0xB3, 0xE4, 0x85,
0xDA, 0xF5, 0x8A, 0x0E, 0x56, 0x41, 0x42, 0xAD,
0xEF, 0x02, 0xAA, 0xBA, 0x31, 0x59, 0x51, 0x15,
0xEB, 0xF7, 0x68, 0x06, 0xAE, 0x4A, 0xCF, 0x21,
0x24, 0xBE, 0xF1, 0x57, 0x9E, 0xC5, 0xC0, 0xCF,
0xE0, 0x1A, 0xC3, 0x9C, 0x70, 0xD3, 0xE4, 0x85,
0x4E, 0xAF, 0x68, 0x4F, 0x55, 0xF1, 0xD9, 0xD5,
0xEF, 0x41, 0xE5, 0xB6, 0xA2, 0xBB, 0x83, 0xA5,
0xC3, 0xE6, 0xF3, 0xB5, 0x24, 0x52, 0x3E, 0x77,
0x0D, 0x0D, 0x1F, 0xA7, 0xE8, 0x81, 0xE9, 0x0C,
0x62, 0x6F, 0x16, 0xE3, 0xFA, 0xFD, 0x23, 0x2C,
0xDE, 0xF7, 0x6F, 0x0D, 0x18, 0x06, 0x8A, 0x18,
0xE0, 0x40, 0x0C, 0x62, 0xC6, 0xE7, 0x63, 0xF2,
0xD2, 0x09, 0x0F, 0xA8, 0x3B, 0x3E, 0xA5, 0x0C,
0xF2, 0x48, 0x2C, 0x43, 0x9F, 0xB9, 0x6F, 0x38,
0xDC, 0x46, 0x98, 0x0C, 0x8B, 0x11, 0xF8, 0x04,
0x64, 0x63, 0x89, 0xA5, 0x73, 0x7D, 0xD8, 0x43,
0xF9, 0x56, 0x09, 0xC5, 0x2B, 0x7F, 0xFA, 0xC1,
0x24, 0x5C, 0xD7, 0xC3, 0x35, 0xE7, 0x66, 0xD1,
0x73, 0x88, 0xD1, 0x3F, 0xA2, 0x60, 0xB8, 0xB8,
0x98, 0x8A, 0x3D, 0xC7, 0xC6, 0xBC, 0xEE, 0x19,
0xA0, 0x3B, 0x79, 0x34, 0x50, 0xA3, 0xD2, 0x5E,
0xF1, 0x50, 0x96, 0x0F, 0x40, 0x88, 0xE7, 0x97,
0x09, 0xC1, 0x05, 0x72, 0x41, 0x96, 0x4C, 0x7B,
0xC1, 0x64, 0xA3, 0x23, 0xC1, 0x32, 0x81, 0xC9,
0x92, 0x58, 0xA2, 0x5C,
0xD8, 0xFC, 0xD2, 0xC4, 0x76, 0xC6, 0x55, 0xFA,
0x2C, 0x73, 0x10, 0x26, 0xE8, 0x2C, 0xF1, 0xF7,
0xE3, 0x15, 0xE4, 0xC7, 0x2B, 0x4F, 0x18, 0x50,
0xD2, 0xC9, 0x71, 0x8D, 0xB2, 0x1C, 0xE2, 0xDE,
0xD9, 0x9F, 0x61, 0xEF, 0x07, 0xF7, 0x85, 0x5B,
0x4F, 0x05, 0xF0, 0x0E, 0xE4, 0xD5, 0x21, 0x7A,
0x15, 0xE6, 0x32, 0xCA, 0xCA, 0x3D, 0xFD, 0x1E,
0x4B, 0xA8, 0x38, 0x61, 0xD0, 0x98, 0xFF, 0x91,
0x6E, 0x76, 0x1F, 0xE1, 0xDF, 0xDB, 0x9E, 0x1F,
0x40, 0x15, 0xC9, 0xF0, 0x00, 0x48, 0xCA, 0xC9,
0xC0, 0xE3, 0xC1, 0xA6, 0x1E, 0xB2, 0xBB, 0x4D,
0x17, 0x7E, 0xDB, 0x29, 0x23, 0x48, 0xF0, 0x9F,
0xD3, 0xD5, 0xE1, 0xA6, 0xA8, 0x6E, 0xB2, 0x75,
0x9A, 0xB6, 0xEC, 0x7A, 0x4A, 0xDA, 0x24, 0xC9,
0x90, 0x1C, 0x37, 0xD8, 0x1B, 0x70, 0xD1, 0x8A,
0x0C, 0xA8, 0xCB, 0xA4, 0x3E, 0x0B, 0x2A, 0x53,
0xB9, 0x65, 0xE9, 0x77, 0xE8, 0x5B, 0x7B, 0xBF,
0x60, 0x40, 0xF5, 0x97, 0xE9, 0xA0, 0xE0, 0x8F,
0x7F, 0x9A, 0x5F, 0x1A, 0xE1, 0xA5, 0xD0, 0xD1,
0xEE, 0x41, 0xEB, 0x7E, 0x77, 0xEF, 0xCB, 0xB5,
0x84, 0x42, 0x47, 0x41, 0xE9, 0xB8, 0xF7, 0x24,
0x58, 0xC5, 0x6C, 0xD5, 0x62, 0xA5, 0x3B, 0x0C,
0x4C, 0xF4, 0x19, 0x37, 0x72, 0x03, 0xF1, 0xBD,
0x67, 0x94, 0x3E, 0x59, 0xC0, 0xEB, 0xE8, 0xFA,
0x27, 0xA8, 0x02, 0xBB, 0xD3, 0x52, 0x71, 0x98,
0xBD, 0xA8, 0x65, 0x35, 0x7A, 0xA0, 0xF1, 0x74,
0x3B, 0x4A, 0xBC, 0xA0, 0xBE,
0xD4, 0x6B, 0x9D, 0xDC, 0x04, 0xB4, 0x63, 0x5F,
0x10, 0xA9, 0x32, 0x2F, 0x24, 0x52, 0x38, 0x37,
0x44, 0x01, 0x67, 0x11, 0x60, 0x0E, 0xC7, 0xAF,
0xD5, 0xD8, 0xC8, 0xA6, 0x0B, 0xCE, 0xF7, 0x7F,
0xA0, 0xB6, 0x1C, 0xA0, 0x98, 0x1C, 0x3F, 0x6D,
0x46, 0x73, 0x28, 0x7E, 0x56, 0x80, 0x37, 0x38,
0x93, 0x6B, 0x45, 0x22, 0xC9, 0x3F, 0x52, 0x53,
0xEA, 0x0D, 0x87, 0x90, 0xEB, 0x57, 0x07, 0x9E,
0xCA, 0xE3, 0x47, 0x8B, 0xCD, 0x8B, 0x25, 0x82,
0xE3, 0x50, 0x59, 0x3F, 0xD3, 0x7C, 0x63, 0xAE,
0xA8, 0xB3, 0xEE, 0x38, 0x9C, 0xFF, 0x8F, 0x21,
0x7D, 0x6B, 0xA1, 0xA1, 0x17, 0x06, 0x18, 0xC7,
0x1A, 0x41, 0x01, 0xD8, 0xF7, 0x3F, 0xC2, 0x63,
0x8A, 0x64, 0x7C, 0x66, 0x6A, 0x2A, 0x6C, 0x90,
0x18, 0x58, 0xE7, 0x66, 0xF3, 0x81, 0xC6, 0x5B,
0xFF, 0x55, 0x76, 0xCD, 0x48, 0xC5, 0xBD, 0x50,
0xF3, 0xAA, 0xFF, 0xBF, 0x5F, 0x74, 0xF6, 0x16,
0x02, 0x1E, 0x0A, 0x44, 0xD0, 0x06, 0xD1, 0x92,
0x95, 0x3D, 0xDC, 0xF3, 0xEF, 0x32, 0xE4, 0x18,
0x65, 0x1D, 0x1E, 0x41, 0x12, 0x9A, 0xD7, 0x23,
0x06, 0x6A, 0x23, 0x9E, 0x12, 0x48, 0xAD, 0x2E,
0x42, 0xAA, 0x66, 0x69, 0x62, 0xBD, 0x7F, 0x0E,
0x0C, 0x93, 0xA1, 0xBC, 0xD5, 0xA6, 0xA4, 0x24,
0xD9, 0xDA, 0xD4, 0xDC, 0xA5, 0x5A, 0x5F, 0xB7,
0xD8, 0x2D, 0x67, 0x3E, 0xA1, 0x00, 0x5B, 0xCD,
0xCE, 0xC8, 0x1C, 0x52, 0x44, 0xE5, 0x80, 0x47,
0xA8, 0xBD, 0x65, 0x6C, 0x6F, 0x3C,
0xFE, 0xA0, 0xA5, 0x60, 0x1E, 0x2D, 0x36, 0x6D,
0x6A, 0xBB, 0xD7, 0x71, 0x16, 0x0C, 0x80, 0xA3,
0x8F, 0x39, 0x78, 0x89, 0x75, 0x12, 0xD9, 0x10,
0xB4, 0xD6, 0x67, 0x58, 0x64, 0x0E, 0x74, 0x73,
0x4C, 0x2E, 0x10, 0x53, 0x05, 0x99, 0xA7, 0x85,
0xF2, 0x73, 0xCE, 0x8B, 0x96, 0xC4, 0xBF, 0xB4,
0xB4, 0x31, 0x23, 0x67, 0x21, 0xC1, 0xF3, 0x58,
0x55, 0x0A, 0xE0, 0x3B, 0xC7, 0xC6, 0x0B, 0x61,
0xFA, 0x1D, 0x7F, 0xFA, 0xF2, 0x84, 0x79, 0x4F,
0xF4, 0xA5, 0x74, 0x83, 0xB2, 0xFD, 0xCF, 0x00,
0xBC, 0x1F, 0xD1, 0x6D, 0x87, 0x88, 0xA6, 0x9A,
0xD8, 0x67, 0x56, 0x2D, 0x44, 0xAD, 0xA4, 0x18,
0xD6, 0x3D, 0x32, 0xBE, 0x52, 0x6D, 0x42, 0x21,
0xFA, 0x09, 0x9F, 0xCF, 0x85, 0xCA, 0x65, 0x62,
0x82, 0xC3, 0x8A, 0xE4, 0xA1, 0xC5, 0x63, 0x98,
0x51, 0x14, 0xBB, 0x95, 0xAE, 0x16, 0xEE, 0x91,
0xC5, 0x1B, 0x1A, 0x65, 0xDC, 0x5D, 0x5F, 0x1B,
0x22, 0xD1, 0x35, 0x6A, 0x37, 0xCC, 0xB4, 0xA4,
0x41, 0x2A, 0xB0, 0x4C, 0x86, 0xB4, 0xF4, 0xE1,
0x3D, 0x24, 0x30, 0x7E, 0xA6, 0xC1, 0x0F, 0x96,
0xA4, 0x36, 0xAF, 0x06, 0xE5, 0x40, 0xCE, 0x22,
0x4C, 0x2E, 0x8E, 0xBC, 0x5B, 0xAD, 0xFF, 0xF6,
0xF0, 0x03, 0xCD, 0x39, 0x02, 0xEC, 0x2C, 0x36,
0xB4, 0xB3, 0x3B, 0xCC, 0x7B, 0xDB, 0xEB, 0x1A,
0xC6, 0x03, 0x0C, 0xDF, 0x65, 0x05, 0xF2, 0xD2,
0x28, 0x4B, 0xAF, 0xE6, 0xD4, 0x66, 0xB6, 0xA6,
0x92, 0x40, 0x4A, 0x70, 0x0F, 0x3E, 0xEE,
0x0E, 0xB6, 0x22, 0xAF, 0x8C, 0xA4, 0x85, 0x62,
0x59, 0x06, 0x99, 0xF1, 0xCB, 0x5C, 0xA4, 0xAA,
0xC8, 0xEF, 0x6A, 0x42, 0xB9, 0xF6, 0x32, 0x62,
0x5F, 0x48, 0x68, 0x24, 0xEB, 0xCF, 0xCF, 0xEA,
0x1D, 0x86, 0x05, 0x2D, 0x75, 0xA1, 0x3B, 0xC5,
0xF6, 0x47, 0xA7, 0x3F, 0x3C, 0x6A, 0x68, 0x38,
0x40, 0x87, 0x92, 0x0A, 0x22, 0xD6, 0x1B, 0x52,
0x50, 0xAE, 0x5C, 0xA1, 0x58, 0x79, 0xCD, 0x0D,
0x25, 0xD6, 0x91, 0xEB, 0xF9, 0x9A, 0x40, 0x9C,
0xCC, 0xEA, 0xFC, 0x0E, 0x23, 0x18, 0x01, 0x27,
0xB2, 0x90, 0xC7, 0x40, 0xD4, 0xE4, 0xBF, 0x1F,
0x1A, 0x93, 0x0A, 0xAB, 0xDC, 0xAE, 0xD8, 0xB6,
0x1A, 0xB7, 0x5D, 0x7B, 0xCD, 0xBD, 0xA8, 0x52,
0xCB, 0x9F, 0x52, 0x49, 0x35, 0xB6, 0x24, 0x3C,
0x0A, 0x3B, 0x6F, 0xD0, 0x76, 0x0E, 0x9D, 0x21,
0x35, 0xF9, 0x2F, 0x58, 0xAA, 0x55, 0x8B, 0xB0,
0x6D, 0x8C, 0xE6, 0x4F, 0x91, 0x56, 0xA7, 0xBF,
0x7D, 0x1B, 0xC5, 0x84, 0x48, 0xBC, 0x91, 0xA8,
0xF8, 0x6F, 0xB7, 0x16, 0x39, 0x52, 0x7F, 0xB5,
0x5C, 0x94, 0x61, 0xB8, 0x21, 0x09, 0x2E, 0xE8,
0x36, 0xC9, 0x80, 0x54, 0x74, 0xAC, 0xFB, 0x0E,
0x83, 0x80, 0x2C, 0x68, 0x21, 0x2C, 0x5D, 0x36,
0x6F, 0x6F, 0xEC, 0x74, 0x23, 0x6F, 0xEB, 0xCB,
0x11, 0x41, 0x80, 0xF8, 0x86, 0x12, 0x90, 0x44,
0x30, 0x24, 0x55, 0x2E, 0xC0, 0x25, 0x81, 0x5B,
0x28, 0x76, 0x71, 0x85, 0x7D, 0x5B, 0x62, 0xEC,
0x53, 0xC9, 0xD0, 0x45, 0xD4, 0x95, 0xD6, 0xC2,
0xDE, 0x4F, 0x9F, 0xFE, 0xC9, 0xFC, 0x15, 0x6A,
0x13, 0xA5, 0x02, 0xF0, 0x13, 0xFD, 0x22, 0x5D,
0xBE, 0x90, 0x90, 0x1D, 0x1F, 0x9E, 0x68, 0x8C,
0xBF, 0xB0, 0x71, 0xA3, 0x16, 0x87, 0x81, 0xFF,
0xE6, 0x93, 0x73, 0x25, 0xB3, 0x7E, 0x15, 0xED,
0x92, 0x55, 0xD8, 0x20, 0xFF, 0x73, 0x16, 0x8E,
0x5C, 0x49, 0x75, 0xE0, 0x19, 0x81, 0x1C, 0x35,
0x15, 0x4B, 0xFF, 0x67, 0x0C, 0x97, 0x98, 0x6D,
0xA7, 0x6F, 0x4E, 0x96, 0xE5, 0x0B, 0x24, 0xF9,
0x0F, 0xBB, 0x86, 0x46, 0xF1, 0xFD, 0x7F, 0x05,
0x09, 0xD7, 0x07, 0xB1, 0x79, 0x9C, 0xDF, 0x83,
0xDD, 0xFD, 0xD5, 0xB3, 0x04, 0x53, 0x23, 0xC1,
0xFE, 0x49, 0x51, 0xDA, 0xA6, 0xD5, 0x23, 0xCA,
0x32, 0xD4, 0x6A, 0xA9, 0x8D, 0x86, 0x50, 0x98,
0x01, 0x7A, 0xFB, 0x1C, 0xFB, 0x79, 0xE6, 0x80,
0x3C, 0xD0, 0x20, 0xED, 0x42, 0xBE, 0x6F, 0x6A,
0x84, 0x4F, 0xD7, 0x40, 0x4D, 0x99, 0x77, 0xF7,
0x49, 0xFE, 0x5B, 0x9C, 0x29, 0x41, 0x6B, 0x06,
0xE5, 0x76, 0x9C, 0x9F, 0x34, 0xB1, 0x43, 0x75,
0x8B, 0x50, 0xCA, 0x33, 0x04, 0xAC, 0x83, 0x8C,
0x93, 0x9E, 0x45, 0x36, 0x60, 0x56, 0x5D, 0x60,
0x43, 0xB5, 0x58, 0x22, 0xEE, 0x2A, 0xC6, 0x76,
0x49, 0x6F, 0xCB, 0x4A, 0x3D, 0xFB, 0x17, 0x7B,
0x4C, 0x54, 0x0B, 0x64, 0xC3, 0xD6, 0x5E, 0x68,
0x0E, 0x52, 0xAB, 0x59, 0x3C, 0xBA, 0xC6, 0xAD,
0x36, 0x44, 0xE3, 0x31, 0x52, 0xEA, 0x0E, 0x53,
0x2F, 0xDB, 0xEA, 0x66, 0x0F, 0xDF, 0x84, 0x9D,
0x55,
0x02, 0x44, 0xC1, 0xD2, 0xA4, 0xB3, 0xB0, 0x19,
0x57, 0xE9, 0x2A, 0x38, 0x35, 0xC3, 0x3B, 0x79,
0x56, 0xE5, 0x9C, 0x26, 0xAC, 0x4C, 0x55, 0x06,
0x6A, 0x36, 0x3C, 0x63, 0xCB, 0x30, 0x73, 0xB6,
0x54, 0x08, 0xFB, 0x99, 0x78, 0xCF, 0x78, 0x56,
0xED, 0x0F, 0x1D, 0x99, 0xBE, 0xA4, 0x4E, 0x7C,
0xE4, 0xD1, 0xE1, 0xA1, 0x7F, 0x97, 0x92, 0x1F,
0xB8, 0x73, 0x7E, 0x97, 0xEB, 0xA4, 0xEE, 0x93,
0x7A, 0x02, 0xAF, 0x76, 0x83, 0x14, 0x56, 0x6E,
0x81, 0x85, 0xFB, 0xBA, 0x57, 0x80, 0xFC, 0xB2,
0xD9, 0xD6, 0xB8, 0xCD, 0x60, 0x01, 0x37, 0x6F,
0xFD, 0xBE, 0x72, 0x0A, 0x0E, 0xEA, 0x1B, 0x1D,
0x1A, 0xB2, 0xBB, 0xFD, 0xAB, 0x0E, 0x94, 0xF6,
0x08, 0x07, 0xA4, 0x98, 0xD3, 0xA8, 0xA6, 0x31,
0x86, 0xE6, 0xAE, 0x30, 0x05, 0x48, 0x9A, 0x37,
0x4A, 0xEE, 0x91, 0xA8, 0x65, 0x74, 0xA7, 0xF3,
0x8D, 0x69, 0x51, 0x6F, 0x8B, 0x0F, 0xF4, 0xE9,
0x23, 0x42, 0x09, 0x3C, 0x3C, 0x7B, 0x4A, 0x21,
0xB3, 0x35, 0xD7, 0xE2, 0x48, 0xD6, 0xCF, 0xB7,
0x07, 0x38, 0x9A, 0x4E, 0xE2, 0xC6, 0x30, 0x8D,
0x7F, 0x2C, 0xA7, 0x57, 0xAF, 0xAA, 0xC3, 0x39,
0xF2, 0x58, 0xC7, 0x39, 0x3D, 0x35, 0xB4, 0x2F,
0x0B, 0x44, 0xED, 0x0D, 0x45, 0x65, 0x8C, 0x04,
0x35, 0x19, 0xFC, 0xDA, 0x6C, 0x12, 0xAE, 0xC1,
0xAA, 0x5B, 0x23, 0x56, 0xFA, 0x00, 0x8C, 0xED,
0xB8, 0x6A, 0x5E, 0xEF, 0x50, 0xD4, 0x83, 0x29,
0xA3, 0x58, 0xC2, 0xCF, 0x4F, 0x40, 0x5C, 0xBA,
0xA2, 0xCE,
0xD6, 0x24, 0xAF, 0x4C, 0x8C, 0xFA, 0xD8, 0x99,
0xBA, 0x61, 0x1F, 0x0C, 0x61, 0x63, 0xB5, 0x54,
0xD7, 0x81, 0x3A, 0x44, 0xE8, 0x7E, 0xAB, 0x43,
0x2F, 0x2D, 0xE5, 0x06, 0xE1, 0x1D, 0xC1, 0x8D,
0x82, 0x1A, 0xDD, 0xE2, 0x92, 0x03, 0x76, 0xAE,
0xE1, 0xB1, 0xF4, 0x68, 0x41, 0xD4, 0x30, 0xCF,
0x85, 0x2A, 0xDA, 0x77, 0xC7, 0xF8, 0xB7, 0x0E,
0xDA, 0x00, 0x49, 0x24, 0xAC, 0x5F, 0xA7, 0xF5,
0x3D, 0x2E, 0x4C, 0xC1, 0xE7, 0x6C, 0xF9, 0x40,
0xE6, 0x7B, 0xCC, 0x4F, 0x75, 0x54, 0x16, 0xEA,
0x56, 0x4A, 0xB7, 0x1C, 0xF3, 0x23, 0xA1, 0xB8,
0xD1, 0xAA, 0xC1, 0x76, 0xA8, 0xB0, 0x61, 0xFC,
0x36, 0xCA, 0x7D, 0x42, 0x2A, 0x73, 0x7E, 0x0D,
0x06, 0x1A, 0x2B, 0x47, 0x10, 0xA9, 0x53, 0xD6,
0xE4, 0x1A, 0x9C, 0x56, 0x9B, 0xA9, 0x67, 0xF5,
0xF7, 0xF5, 0x32, 0x4B, 0xE2, 0x2F, 0x34, 0xE2,
0x61, 0x9A, 0x76, 0x07, 0x4D, 0xF3, 0x33, 0x9D,
0xFC, 0xFC, 0x22, 0x26, 0xBB, 0x2E, 0x55, 0xD6,
0xCF, 0xED, 0xA2, 0xE7, 0x2D, 0xB3, 0xF2, 0x42,
0x53, 0x09, 0xC2, 0xDF, 0x51, 0x5D, 0xCE, 0xE1,
0xD9, 0x3E, 0x2E, 0xE8, 0x98, 0x4B, 0xDE, 0x42,
0xC1, 0xBB, 0x88, 0xF5, 0x01, 0xD6, 0xD3, 0x23,
0x22, 0xD1, 0x39, 0x71, 0xF1, 0xC9, 0x2E, 0xC8,
0xAD, 0x0F, 0xFA, 0xEB, 0x6D, 0x47, 0xB1, 0x43,
0x60, 0x91, 0x49, 0x7E, 0xD7, 0x18, 0xB7, 0xBE,
0x66, 0x0C, 0xA5, 0xF9, 0x65, 0x62, 0x41, 0x4A,
0x9D, 0x77, 0xF7, 0x09, 0x3C, 0x98, 0x55, 0x46,
0x5E, 0xAF, 0x56,
0x8F, 0xA1, 0x40, 0xB9, 0xC4, 0x8E, 0x74, 0xE5,
0x4D, 0x77, 0xB3, 0x07, 0x2C, 0xDB, 0x4F, 0x40,
0xF8, 0x22, 0x87, 0x63, 0x32, 0x58, 0x16, 0x24,
0x43, 0x17, 0x0C, 0x8D, 0x63, 0xE3, 0x67, 0x92,
0x1B, 0x6E, 0x5F, 0xE5, 0xFC, 0x9B, 0xD5, 0xD5,
0x73, 0xE0, 0x57, 0xDE, 0x22, 0x70, 0x9C, 0xB9,
0x26, 0xB3, 0x41, 0x05, 0x62, 0x9D, 0x48, 0x64,
0x81, 0x81, 0x91, 0x58, 0xFC, 0xCB, 0xBC, 0x53,
0xE5, 0xC8, 0xB6, 0x2D, 0x00, 0xB6, 0x5F, 0xEB,
0xBC, 0x2C, 0x5A, 0xFD, 0xD9, 0xD4, 0x74, 0x58,
0x90, 0xE6, 0x37, 0xBF, 0xDE, 0x73, 0x35, 0x14,
0x37, 0x08, 0x21, 0x80, 0x1E, 0x68, 0x2B, 0xB4,
0x72, 0x7E, 0x81, 0x39, 0x7E, 0xF8, 0xDE, 0x07,
0xF3, 0xA3, 0xC0, 0xA1, 0x3F, 0x9A, 0xA4, 0x1D,
0x22, 0xF9, 0x52, 0x8F, 0x7D, 0x1D, 0x31, 0x6B,
0xE3, 0x81, 0xED, 0x97, 0x6F, 0x73, 0xA6, 0x00,
0xC9, 0x02, 0xD1, 0xA7, 0xBC, 0x9C, 0x63, 0xBB,
0xE3, 0x60, 0x3E, 0x20, 0x3F, 0x0B, 0x32, 0x02,
0x23, 0x9E, 0x09, 0xE3, 0x00, 0x44, 0xA6, 0x7D,
0x56, 0x99, 0x1B, 0xAF, 0x17, 0x07, 0xB6, 0x74,
0x05, 0x0F, 0x2B, 0x5A, 0xE4, 0xF5, 0x14, 0xA5,
0x69, 0xAE, 0xDA, 0x77, 0x13, 0x7A, 0x89, 0x5A,
0x90, 0xA1, 0x5E, 0x39, 0x63, 0x0A, 0xFF, 0xE5,
0x7C, 0xB4, 0xB2, 0xC1, 0xC3, 0x38, 0x7D, 0x95,
0xD9, 0x9E, 0x45, 0x6B, 0x10, 0xCB, 0x40, 0x16,
0x18, 0x78, 0xCC, 0x3E, 0xEF, 0x5C, 0x97, 0x19,
0x65, 0xDA, 0x78, 0xD4, 0x27, 0xD2, 0xFF, 0x6C,
0x6C, 0x15, 0x19, 0x21,
0x5D, 0xBA, 0x26, 0x65, 0xE5, 0xC3, 0x2F, 0xBB,
0x14, 0x04, 0x83, 0x26, 0x35, 0x31, 0x46, 0x0E,
0xB3, 0x60, 0xAA, 0x67, 0x52, 0x6F, 0xCA, 0x2E,
0xA6, 0xCF, 0x1B, 0x23, 0xBF, 0xD3, 0x07, 0xF1,
0x9C, 0x8B, 0x34, 0xF2, 0x67, 0x96, 0xCF, 0x79,
0x59, 0x33, 0x20, 0x12, 0x97, 0xB8, 0x58, 0x66,
0xDE, 0x94, 0xA3, 0xD9, 0x28, 0xC6, 0x30, 0xB9,
0x38, 0x19, 0x61, 0x65, 0xE7, 0xCD, 0x5B, 0x46,
0x6F, 0x1C, 0x6F, 0x73, 0xDA, 0xF6, 0x1D, 0xD6,
0x71, 0xB0, 0x64, 0xDC, 0x16, 0x48, 0x54, 0x00,
0x26, 0x16, 0x2D, 0xBA, 0x54, 0xC6, 0x52, 0xA1,
0xBE, 0xA7, 0x37, 0xB6, 0xB2, 0xC0, 0xDA, 0xE5,
0xE7, 0xE9, 0xF9, 0x9E, 0x45, 0x93, 0x9A, 0x49,
0x9F, 0xF3, 0x56, 0x6D, 0x46, 0x6C, 0x8A, 0x4F,
0x4E, 0xF6, 0x41, 0x7B, 0xA6, 0x8A, 0x18, 0xC0,
0xD7, 0x3E, 0xA9, 0x05, 0x21, 0x99, 0xA4, 0x97,
0x51, 0x8B, 0x9B, 0x37, 0x93, 0x92, 0x62, 0x71,
0xD9, 0x6F, 0xD8, 0x4C, 0xD2, 0x81, 0x06, 0xD2,
0xFB, 0x59, 0xFD, 0xD5, 0x8B, 0x09, 0xED, 0x28,
0x26, 0xB4, 0xD9, 0x57, 0xD8, 0xED, 0xCF, 0xD4,
0x95, 0xB0, 0x64, 0x68, 0xD5, 0xE0, 0x52, 0xDC,
0xE7, 0x6E, 0x24, 0xD1, 0x7F, 0x15, 0x71, 0xE6,
0x7B, 0x74, 0x31, 0xFB, 0x5B, 0x66, 0x55, 0x1A,
0xD7, 0x5F, 0x91, 0x53, 0x8C, 0x26, 0x41, 0x02,
0xF7, 0x4A, 0xC0, 0x4F, 0x7E, 0x49, 0x3A, 0xA6,
0x65, 0x30, 0x2D, 0x3D, 0x4A, 0xED, 0x4B, 0x63,
0x3A, 0xF8, 0xB0, 0x7D, 0x48, 0xA3, 0xD9, 0x77,
0x37, 0xFC, 0x54, 0x49, 0x06,
0x83, 0x69, 0x14, 0xF3, 0x3D, 0x48, 0x43, 0x28,
0xE6, 0xC4, 0x87, 0x37, 0x5A, 0xC4, 0x57, 0x0D,
0xC5, 0xF5, 0x2E, 0xC2, 0xC2, 0x68, 0x09, 0xE9,
0xB4, 0x86, 0x6C, 0xDE, 0x79, 0x39, 0x5D, 0xE5,
0x84, 0x71, 0xE1, 0x65, 0x7A, 0x0B, 0xB3, 0xCC,
0xA2, 0x3E, 0x99, 0x3E, 0x95, 0x47, 0xAD, 0xC1,
0x65, 0xFF, 0x82, 0x39, 0xBC, 0xD5, 0x64, 0x3D,
0x8A, 0x79, 0xC1, 0xDE, 0xFE, 0xDB, 0xA4, 0x00,
0x0F, 0xB9, 0xD5, 0x05, 0x79, 0x13, 0xFF, 0x40,
0x35, 0xDF, 0xAE, 0xE0, 0x6A, 0xCA, 0x73, 0x87,
0x7A, 0xE7, 0x95, 0x4E, 0xE6, 0x26, 0x41, 0x2D,
0xFF, 0x5F, 0xC9, 0xFB, 0x9A, 0x5E, 0x96, 0x07,
0xCB, 0xF4, 0x79, 0x2B, 0x40, 0x0F, 0x77, 0x82,
0x38, 0x9E, 0x11, 0xDB, 0xBE, 0xFD, 0x20, 0x76,
0xAB, 0xB7, 0x55, 0x3B, 0x92, 0xD6, 0xA6, 0xD0,
0xEB, 0xCF, 0xC0, 0x02, 0x78, 0xA0, 0x6B, 0x02,
0xFC, 0xC6, 0x0F, 0xAE, 0xAB, 0xDD, 0x10, 0x96,
0x1B, 0x50, 0xF1, 0x78, 0xB7, 0x11, 0xCD, 0x4D,
0x9B, 0xC6, 0x63, 0xBF, 0x66, 0x41, 0xA0, 0xA1,
0xED, 0x8B, 0xD6, 0x66, 0xD8, 0x0B, 0xD5, 0x71,
0xA5, 0xAF, 0x1F, 0x39, 0xCB, 0x9E, 0xC4, 0xDE,
0x23, 0x24, 0xBE, 0xFD, 0x52, 0xE8, 0x2C, 0x6E,
0x54, 0x63, 0x40, 0x02, 0xE2, 0x21, 0x7A, 0xBA,
0x59, 0x08, 0xDC, 0x89, 0xF2, 0x04, 0xD6, 0xE7,
0xAB, 0x62, 0xDF, 0x65, 0xF9, 0x36, 0x90, 0x1E,
0x06, 0xC9, 0x90, 0x8F, 0xB2, 0xB6, 0x66, 0xD2,
0x6B, 0x3C, 0xA2, 0x4E, 0x50, 0xAA, 0x0B, 0x9A,
0xE6, 0xDC, 0x28, 0x82, 0xE9, 0xAE,
0x31, 0x5A, 0xCD, 0x3A, 0x28, 0xB1, 0xF5, 0xA9,
0xAD, 0xE7, 0xBB, 0xA2, 0xF7, 0x78, 0x4D, 0xB8,
0x0C, 0x6E, 0x38, 0xE4, 0xFB, 0xEB, 0xD8, 0x0C,
0x99, 0x42, 0xE7, 0x90, 0xEC, 0xC4, 0x74, 0x20,
0xAF, 0x8B, 0x26, 0xC0, 0x1D, 0x6C, 0xD2, 0xE0,
0x41, 0x64, 0xAE, 0x9A, 0x35, 0xBE, 0xD1, 0x83,
0x73, 0x74, 0x0F, 0xAB, 0x2D, 0x28, 0x79, 0xB6,
0x96, 0x9E, 0x75, 0x13, 0xF8, 0xFE, 0x1D, 0xA9,
0x97, 0x6D, 0x0A, 0x22, 0x74, 0x97, 0xEE, 0x7E,
0xC1, 0x7E, 0x2C, 0x07, 0x0E, 0xA6, 0x62, 0xCC,
0x7C, 0xC6, 0xB7, 0xF1, 0x24, 0xB0, 0xAA, 0xAB,
0xDD, 0xB6, 0x62, 0x2F, 0x4C, 0x70, 0xF8, 0x6A,
0x3E, 0x84, 0xD5, 0x32, 0x11, 0xBA, 0x86, 0x3C,
0xB3, 0xF2, 0x9C, 0x99, 0x3C, 0x12, 0x50, 0xBE,
0x45, 0x93, 0x4D, 0x40, 0x0C, 0x71, 0xD9, 0xCE,
0x98, 0xE4, 0x38, 0x07, 0x63, 0xED, 0xA5, 0x69,
0x76, 0x38, 0x48, 0xF2, 0x7B, 0x13, 0x3B, 0xA5,
0x11, 0x03, 0xC5, 0xEA, 0xA4, 0x32, 0x77, 0xC2,
0xC8, 0xA7, 0x76, 0x1A, 0x78, 0x09, 0x89, 0x5E,
0xCD, 0xF0, 0xF9, 0x3B, 0xDC, 0xEF, 0x0C, 0xA9,
0xB8, 0x6D, 0xB5, 0x4B, 0xD0, 0x3C, 0x92, 0xE6,
0x03, 0xB2, 0x27, 0x07, 0x61, 0x34, 0xE1, 0x6C,
0x6B, 0xB4, 0xAF, 0x00, 0x9F, 0xD6, 0x5A, 0x7A,
0x00, 0x12, 0x0C, 0xB8, 0x05, 0x91, 0x81, 0x2D,
0x0E, 0xB8, 0xE8, 0x92, 0x87, 0x85, 0x5D, 0xED,
0x97, 0xD7, 0x96, 0xA8, 0xA2, 0xA4, 0xA2, 0xEF,
0xE7, 0x73, 0xF8, 0xC0, 0x65, 0xB6, 0xE5, 0xDF,
0x97, 0xB2, 0x93, 0x93, 0x23, 0xDD, 0x4A,
0x9A, 0x7C, 0xB4, 0xAE, 0x90, 0xD0, 0xB5, 0x39,
0x2A, 0xF9, 0xA6, 0x8C, 0xDA, 0xF8, 0x8F, 0x86,
0xEA, 0x7D, 0xE4, 0x3A, 0x67, 0xD0, 0xA6, 0xAA,
0x1F, 0x53, 0x34, 0x64, 0x67, 0xAC, 0x9C, 0x02,
0x8A, 0xD7, 0xBE, 0x7D, 0x47, 0x33, 0x22, 0x05,
0x25, 0xA6, 0x92, 0x6B, 0x5F, 0x40, 0x7B, 0x9F,
0x95, 0x07, 0x1E, 0x33, 0x88, 0x04, 0xC6, 0x7B,
0x5F, 0xE5, 0xEC, 0x90, 0xB6, 0x24, 0x5F, 0x4B,
0x10, 0xF7, 0x85, 0xD4, 0x16, 0x2C, 0x69, 0x76,
0x80, 0x32, 0x86, 0x3B, 0x3B, 0x78, 0x78, 0xCA,
0x61, 0x9E, 0x45, 0x4D, 0x7A, 0x24, 0x93, 0xE6,
0x1F, 0xD9, 0x9E, 0x75, 0x59, 0xB7, 0x94, 0x5F,
0x75, 0x5E, 0xB5, 0x51, 0x8B, 0xE5, 0x3E, 0x4E,
0x77, 0xBA, 0xA3, 0x32, 0x0F, 0x7C, 0x38, 0x57,
0x90, 0x71, 0xBA, 0x0B, 0x9F, 0xE8, 0xB5, 0xC3,
0x61, 0x2A, 0x6E, 0xC5, 0xE5, 0x71, 0x48, 0xA0,
0x72, 0x70, 0x07, 0xFE, 0x8F, 0xE9, 0x67, 0xC7,
0xB9, 0x31, 0x63, 0xB7, 0xF8, 0x15, 0xCC, 0xDC,
0x93, 0x8B, 0x90, 0x4E, 0x42, 0x23, 0xED, 0x70,
0x22, 0x99, 0xB5, 0xDD, 0xE3, 0x1C, 0xDF, 0x28,
0x9D, 0x01, 0xB3, 0xC7, 0xC0, 0x67, 0x06, 0x4B,
0x8F, 0x9B, 0xDD, 0x2E, 0x07, 0x2C, 0x60, 0xB0,
0xA3, 0x3F, 0x7C, 0x0B, 0x43, 0x17, 0xE4, 0xFA,
0x34, 0x78, 0xE9, 0x9B, 0xD5, 0xF8, 0xCC, 0xDE,
0xE2, 0xA9, 0x00, 0x6E, 0x20, 0x0E, 0x16, 0xB4,
0x68, 0x8B, 0x79, 0x8A, 0xC1, 0xBB, 0x8B, 0x2F,
0xD6, 0xF2, 0x71, 0x39, 0x30, 0x75, 0x6B, 0x5A,
0x04, 0x30, 0x0D, 0x71, 0x74, 0xFC, 0x10, 0xC1,
0x12, 0x2F, 0x6E, 0xC2, 0xB6, 0x22, 0x2E, 0x2E,
0x92, 0x8E, 0xDE, 0x8E, 0x47, 0xF8, 0x7B, 0xB8,
0xB6, 0xF8, 0xE0, 0x96, 0xF9, 0x9F, 0xAD, 0x15,
0xB8, 0x61, 0x4D, 0x80, 0xA1, 0x5C, 0x09, 0x79,
0x0F, 0xB6, 0x90, 0xA0, 0x0B, 0x2D, 0x93, 0x74,
0x7E, 0x87, 0x16, 0xE8, 0x5D, 0x8B, 0x7E, 0xD5,
0xD1, 0x69, 0xE0, 0xF5, 0x68, 0xD5, 0x49, 0xED,
0xC9, 0x22, 0x30, 0xF9, 0x0E, 0xB3, 0xAD, 0xC7,
0x40, 0x62, 0x35, 0x05, 0x6F, 0xFB, 0xA0, 0x73,
0xC3, 0x8E, 0xB7, 0xA5, 0x2C, 0x3F, 0x04, 0xF7,
0x71, 0x5D, 0x5C, 0xD7, 0xE8, 0xF4, 0x84, 0xC2,
0x3C, 0x8A, 0xE5, 0x7A, 0xF0, 0x6E, 0x6A, 0xA2,
0xF0, 0x09, 0x68, 0xBD, 0xD2, 0xB3, 0x47, 0xD9,
0x42, 0x82, 0xA5, 0xB9, 0x2D, 0x33, 0x97, 0x3E,
0x92, 0x62, 0xAC, 0xA9, 0x01, 0x04, 0x15, 0x77,
0xA4, 0xF8, 0x1F, 0x1C, 0x91, 0x98, 0xAD, 0x38,
0x61, 0x2A, 0xC2, 0x0F, 0x85, 0xBE, 0x2A, 0xCF,
0xC1, 0x4A, 0x64, 0x5E, 0x2C, 0xBB, 0xBA, 0xB1,
0xB7, 0xB5, 0x3F, 0x5F, 0x87, 0x30, 0xFD, 0x65,
0x64, 0xCE, 0x72, 0x37, 0x92, 0xF6, 0x62, 0xEA,
0x33, 0xCE, 0x78, 0xFF, 0x84, 0x4B, 0xFD, 0x13,
0x7D, 0xD1, 0x33, 0xF3, 0xF6, 0x32, 0xB4, 0xD7,
0x79, 0x8A, 0x70, 0x1A, 0xCE, 0xBF, 0x42, 0x1F,
0x4C, 0xB8, 0x62, 0x95, 0x94, 0x9D, 0xF2, 0xBE,
0x77, 0x70, 0xBD, 0x3B, 0x2F, 0x76, 0xAB, 0x18,
0x96, 0xC7, 0xF2, 0x8D, 0xAC, 0x3C, 0xB2, 0x48,
0xA9, 0xF5, 0xA5, 0xB8, 0x52, 0xEB, 0xE7, 0x9B,
0xE7, 0x6F, 0x88, 0x2E, 0x3F, 0xA5, 0x00, 0xAE,
0x7F,
0x89, 0x1B, 0xC8, 0xF9, 0x92, 0x73, 0x9A, 0x5F,
0xEB, 0x51, 0x24, 0x53, 0x52, 0x97, 0x03, 0x08,
0x4B, 0x5C, 0xAE, 0x9F, 0x31, 0x72, 0x8E, 0x72,
0xDA, 0x8F, 0x8F, 0x9F, 0x58, 0x75, 0x6B, 0xE1,
0xDC, 0x68, 0xC2, 0x68, 0xA1, 0x92, 0x9A, 0x20,
0x32, 0x32, 0x33, 0x73, 0x02, 0xB2, 0x1A, 0xCD,
0xE2, 0x45, 0xFB, 0x08, 0x0D, 0x2D, 0xF1, 0xD6,
0x30, 0x66, 0x4C, 0x01, 0x09, 0xF5, 0x8B, 0x9A,
0xDE, 0xFC, 0x49, 0xA5, 0x71, 0xA0, 0x6F, 0x7D,
0x31, 0x2C, 0xFB, 0x28, 0x50, 0x01, 0x3E, 0xDA,
0x21, 0xD8, 0xD0, 0xA3, 0x00, 0x9E, 0x92, 0x5B,
0x0D, 0x41, 0x4E, 0xBC, 0xDB, 0xAF, 0x50, 0x1D,
0x29, 0x09, 0x3C, 0x6F, 0xF9, 0xC3, 0x45, 0xD8,
0x51, 0x4E, 0xCF, 0x74, 0x77, 0xA8, 0xF7, 0xFB,
0x19, 0xC7, 0xEF, 0x24, 0x35, 0xAE, 0xA3, 0xCE,
0x2A, 0x07, 0x74, 0x70, 0x83, 0x6D, 0x47, 0xC8,
0xB3, 0x06, 0xEA, 0xF8, 0x4D, 0xFC, 0xAF, 0xA2,
0x94, 0xA7, 0x61, 0x0E, 0x90, 0x67, 0x6D, 0x7A,
0x3E, 0x16, 0x95, 0x29, 0xE2, 0x88, 0xAC, 0x9C,
0x2D, 0xDB, 0x35, 0x38, 0x39, 0x00, 0x25, 0x07,
0xB7, 0xEC, 0x6F, 0x32, 0x94, 0x92, 0xC2, 0x9E,
0xC8, 0xBD, 0x41, 0x1F, 0x31, 0x67, 0xD2, 0x08,
0x66, 0xB6, 0x59, 0x61, 0x20, 0xEA, 0x26, 0xB0,
0xAD, 0x1F, 0x6F, 0x0D, 0x9F, 0x41, 0x0E, 0xB0,
0x41, 0xA5, 0x5D, 0xA7, 0x6F, 0x2E, 0x0D, 0x0A,
0x16, 0x04, 0xAC, 0xEA, 0x41, 0x58, 0x79, 0x5C,
0x6E, 0x7E, 0x65, 0xC1, 0x79, 0x5E, 0xC6, 0x01,
0x6F, 0xAB, 0x7F, 0xF3, 0x07, 0x3B, 0x26, 0x3C,
0x1B, 0x49,
0x38, 0x1A, 0x06, 0x13, 0xE6, 0x67, 0x19, 0xD5,
0xA5, 0x16, 0xF6, 0x02, 0xEF, 0xFF, 0xFA, 0xB6,
0x37, 0xED, 0x5F, 0xB3, 0x9E, 0x88, 0x18, 0x97,
0xAC, 0xDA, 0xE2, 0x3B, 0x45, 0x5D, 0x0A, 0xD7,
0xCA, 0x89, 0x8F, 0x3F, 0x50, 0x03, 0xC9, 0x2F,
0xCE, 0x44, 0x27, 0x90, 0x33, 0xE7, 0xFB, 0xF0,
0x1C, 0x4B, 0x05, 0x6B, 0x15, 0xC0, 0x5E, 0x68,
0x47, 0x9C, 0x8A, 0xFE, 0xEC, 0x88, 0x1F, 0xBD,
0x2F, 0x53, 0x97, 0x11, 0x45, 0x2B, 0x74, 0x94,
0x28, 0x46, 0xAD, 0x40, 0x6B, 0xC8, 0x60, 0x62,
0x66, 0xAE, 0x73, 0x0E, 0x1B, 0xB8, 0xD3, 0x49,
0xE4, 0x1B, 0xE0, 0xA1, 0xA1, 0x33, 0x2C, 0xAF,
0x63, 0x04, 0x7E, 0xFD, 0x58, 0xF3, 0xA0, 0x20,
0xBA, 0x31, 0xA9, 0xA6, 0x41, 0xD3, 0x1E, 0x74,
0x94, 0xF1, 0x70, 0x2C, 0x3D, 0x3F, 0x86, 0xD1,
0x8E, 0x89, 0x86, 0x79, 0x8E, 0x60, 0x6A, 0xB3,
0xF8, 0x79, 0x7B, 0x42, 0xC2, 0x1D, 0xFD, 0x6D,
0x96, 0xBF, 0x09, 0xC5, 0x2D, 0xEC, 0xAD, 0xDE,
0xF3, 0xC3, 0x22, 0x6D, 0x2B, 0x28, 0x47, 0xA6,
0x46, 0x21, 0x53, 0xAF, 0x58, 0xEE, 0x5D, 0x9A,
0x8C, 0x48, 0x0D, 0xD1, 0x27, 0x26, 0x1A, 0x18,
0x2C, 0x78, 0x2D, 0x08, 0x41, 0x88, 0x21, 0x33,
0xA1, 0x69, 0xA1, 0x80, 0x82, 0x62, 0x77, 0xA2,
0x15, 0xB2, 0x11, 0x40, 0x30, 0xCF, 0xD9, 0xC9,
0x24, 0xA0, 0x04, 0xF4, 0xCB, 0xAE, 0x5D, 0x4D,
0x7C, 0x2D, 0x59, 0xBD, 0xE3, 0x15, 0x19, 0xFE,
0xDF, 0x82, 0xC0, 0x12, 0xBE, 0x36, 0xCA, 0x7C,
0x12, 0xE7, 0x31, 0x08, 0x2C, 0xD6, 0x09, 0xE6,
0x36, 0x05, 0x72,
0xF0, 0x0A, 0x19, 0x26, 0xD6, 0xE5, 0xAE, 0x32,
0xCD, 0x58, 0x7B, 0xE9, 0x8C, 0x49, 0xF3, 0xBF,
0x77, 0xCA, 0x34, 0x3E, 0xD0, 0x0B, 0xAA, 0xCE,
0x59, 0x5C, 0xFB, 0x4D, 0x55, 0xB2, 0x7D, 0xF5,
0x62, 0xC1, 0x99, 0xDE, 0xF0, 0x74, 0xB3, 0xA2,
0xBB, 0x2D, 0x8B, 0xC7, 0xC8, 0x18, 0x51, 0x94,
0x8B, 0xE6, 0x38, 0xC3, 0xF7, 0x9E, 0x3A, 0x1B,
0xB5, 0x98, 0x41, 0xBE, 0x99, 0xC0, 0x31, 0xA2,
0x4D, 0x3B, 0xAF, 0x36, 0xE3, 0x0B, 0xD9, 0xC8,
0xA8, 0x7B, 0xAE, 0xE9, 0x84, 0x13, 0x58, 0xB2,
0x03, 0x80, 0xF4, 0xB8, 0x48, 0x24, 0xD7, 0x45,
0xB4, 0xA4, 0x40, 0xEB, 0xE3, 0xBD, 0x4B, 0xC7,
0x96, 0xE1, 0x7D, 0x00, 0x1E, 0x4E, 0x96, 0x4B,
0x22, 0xE3, 0x81, 0xAB, 0xB0, 0x44, 0x3F, 0xD4,
0xBF, 0x88, 0x20, 0xF6, 0x65, 0x88, 0x04, 0xB8,
0xAE, 0xFF, 0x0A, 0x80, 0x54, 0x99, 0xFD, 0x72,
0xD8, 0x40, 0x0D, 0xB9, 0x04, 0x43, 0x76, 0x7B,
0x2C, 0x36, 0x50, 0xFA, 0x18, 0xD0, 0x6B, 0x46,
0x10, 0x1E, 0xE4, 0x87, 0xD2, 0x61, 0x1B, 0xC9,
0x62, 0x3C, 0xB5, 0x8B, 0xBF, 0x0B, 0xF5, 0x63,
0x64, 0x24, 0xC0, 0x38, 0x79, 0x83, 0xF2, 0x02,
0x1C, 0x4D, 0xD7, 0xBE, 0x3E, 0x70, 0x17, 0xA4,
0x71, 0x25, 0xA6, 0xB2, 0x0B, 0x22, 0x36, 0x09,
0x27, 0xF9, 0x7E, 0x46, 0x2B, 0xCE, 0x87, 0x43,
0x45, 0x81, 0x68, 0x29, 0xC9, 0x3B, 0xF7, 0x2A,
0xCD, 0xAE, 0xD9, 0x5E, 0xDC, 0xDC, 0x86, 0xB3,
0x12, 0x8F, 0x8B, 0xCA, 0xD0, 0x28, 0x67, 0x81,
0x2A, 0x21, 0xDC, 0x91, 0x2B, 0xC6, 0xAC, 0x42,
0x2D, 0x5D, 0xF3, 0xEF,
0x46, 0x20, 0x6F, 0x43, 0xE5, 0x00, 0xA9, 0xA4,
0xF9, 0xF4, 0x78, 0xC4, 0x96, 0x45, 0xA8, 0x91,
0x2B, 0x44, 0x4B, 0xED, 0x73, 0x6B, 0xCD, 0x16,
0x80, 0x27, 0x2E, 0x29, 0xA1, 0x24, 0xA2, 0x8A,
0xCC, 0x20, 0xE4, 0x67, 0xA1, 0x21, 0xF7, 0x1C,
0xD6, 0x3C, 0xCB, 0xF7, 0x6F, 0x5D, 0x9D, 0x2B,
0xD8, 0xD7, 0xCA, 0x13, 0x90, 0x55, 0xD1, 0x30,
0x61, 0xE2, 0x4F, 0x36, 0x55, 0xC2, 0x11, 0x8F,
0xF3, 0x2C, 0x2D, 0xCA, 0x8F, 0x24, 0xA7, 0x4C,
0xA0, 0x9A, 0x59, 0x60, 0xD6, 0x9A, 0x70, 0xFE,
0x2E, 0x2B, 0xEA, 0x80, 0xC3, 0x44, 0xF9, 0xE7,
0x14, 0x68, 0xDB, 0xF4, 0xBD, 0x39, 0xA3, 0x36,
0x40, 0xF8, 0xF8, 0xD8, 0xEF, 0xEC, 0xE9, 0x33,
0xDF, 0xAE, 0x61, 0x07, 0x78, 0xDC, 0x58, 0x47,
0x31, 0x5E, 0xBC, 0x03, 0x51, 0xF1, 0x73, 0x21,
0xB3, 0x3F, 0x63, 0x68, 0xFD, 0x8C, 0xB3, 0xD2,
0x39, 0xED, 0x5C, 0xBF, 0x2B, 0x1D, 0x24, 0xA2,
0x78, 0xF5, 0x81, 0x00, 0xFE, 0xBB, 0x32, 0xAA,
0x12, 0xF1, 0xE6, 0x95, 0x69, 0x52, 0x9E, 0xCA,
0x8E, 0x0A, 0x6A, 0xD6, 0xD1, 0x1F, 0x94, 0xE9,
0xA4, 0x45, 0x7F, 0x2D, 0xA8, 0x8E, 0x15, 0x89,
0xEE, 0x3B, 0x41, 0x9D, 0x99, 0x5D, 0xB8, 0x0E,
0x24, 0x33, 0xF5, 0xA9, 0x01, 0x3C, 0xB9, 0x84,
0x64, 0x96, 0x17, 0x51, 0x5E, 0x56, 0x60, 0x3C,
0xF4, 0xBA, 0x2A, 0x74, 0xE4, 0x8A, 0xF0, 0xF4,
0x85, 0x91, 0xC1, 0xEF, 0x50, 0xB0, 0x8D, 0x73,
0xD3, 0x13, 0x5D, 0x22, 0xB3, 0xBA, 0xDD, 0xC1,
0x95, 0x55, 0x6A, 0xC8, 0xC1, 0x59, 0xC0, 0xFA,
0x88, 0x1D, 0xC9, 0x9F, 0x06,
0x12, 0x6D, 0xBE, 0x2D, 0x17, 0x1A, 0x3F, 0xF2,
0x4C, 0x96, 0x48, 0xFD, 0x05, 0xEA, 0x73, 0xDE,
0xCF, 0x8C, 0x3F, 0xC3, 0x6E, 0x12, 0xE6, 0xD1,
0x74, 0xC3, 0xEA, 0xEF, 0x55, 0xDC, 0x4B, 0xAE,
0x32, 0x9E, 0x2F, 0xC8, 0xDD, 0x7C, 0x60, 0xAB,
0x4F, 0xD7, 0xFD, 0x49, 0xBC, 0x80, 0x11, 0x8A,
0xAF, 0xC0, 0xED, 0xB5, 0xD5, 0x35, 0xBE, 0x0F,
0x4F, 0xF4, 0x48, 0xD4, 0xD6, 0xC0, 0xF1, 0x1A,
0x5E, 0x1B, 0x70, 0x92, 0x97, 0x5D, 0x67, 0x75,
0xD8, 0xE0, 0xB5, 0xE0, 0x18, 0x30, 0x7E, 0x46,
0x37, 0x86, 0xF3, 0x4C, 0x13, 0x58, 0x68, 0x02,
0x72, 0xBD, 0xEB, 0x72, 0xE4, 0xBE, 0x8B, 0x59,
0x6F, 0x57, 0xEB, 0x61, 0x15, 0x00, 0xA6, 0x36,
0x2C, 0xAC, 0x74, 0xE7, 0xD6, 0xCC, 0x00, 0x6A,
0x30, 0x1D, 0xFB, 0xA5, 0xC5, 0x2D, 0x4C, 0xE7,
0x73, 0x32, 0xD2, 0x6D, 0x80, 0x64, 0x57, 0x93,
0x0C, 0x86, 0xA3, 0x08, 0x8F, 0x7D, 0xEA, 0x8C,
0x93, 0x78, 0xC9, 0x56, 0xCC, 0x33, 0xED, 0xA3,
0xB7, 0xAD, 0x2D, 0x27, 0x30, 0x87, 0x26, 0x8E,
0x79, 0x8C, 0xEE, 0x9F, 0xB0, 0x60, 0x53, 0x5C,
0xC6, 0x07, 0x7E, 0xDF, 0x54, 0x5C, 0x2E, 0xB5,
0xEF, 0x00, 0xE4, 0xDC, 0xF7, 0xC7, 0xAE, 0x60,
0xF6, 0xE5, 0x50, 0x75, 0x6A, 0x17, 0x4B, 0xDA,
0xCE, 0x4D, 0xFB, 0x8F, 0xAF, 0x97, 0x7A, 0x25,
0x2A, 0x9F, 0x04, 0xB8, 0xD1, 0x26, 0x72, 0x4A,
0x14, 0x8C, 0x8A, 0x1B, 0x7E, 0xCC, 0x42, 0x9E,
0x22, 0x67, 0x30, 0xC9, 0xC9, 0xC5, 0xF5, 0x0E,
0x95, 0xCD, 0xAE, 0xC2, 0x48, 0x7E, 0xA9, 0x00,
0x33, 0x9D, 0xE4, 0xD0, 0xD3, 0x6A,
0xC0, 0xB4, 0x3E, 0xCC, 0xD2, 0xA0, 0xCC, 0xD8,
0xDD, 0xBB, 0xF6, 0xF4, 0x26, 0x7A, 0xA8, 0xC2,
0x38, 0xAF, 0x52, 0xF1, 0xDB, 0xE4, 0xEA, 0xF2,
0xCD, 0x92, 0x5D, 0x1A, 0x9F, 0xA0, 0x0D, 0xE0,
0x86, 0x9A, 0xB7, 0x90, 0xE5, 0x1C, 0x96, 0x9E,
0x75, 0xA8, 0x59, 0x27, 0x19, 0x9A, 0xF4, 0xCA,
0x56, 0xC8, 0x66, 0xB9, 0x0D, 0x1E, 0x88, 0xE1,
0x78, 0x2A, 0x8A, 0x6B, 0x81, 0x95, 0xE7, 0x38,
0xD7, 0xE8, 0xFD, 0xD9, 0x67, 0xED, 0x25, 0xF5,
0x9F, 0x4E, 0x5B, 0xCA, 0x91, 0xDF, 0xDE, 0x2F,
0xAD, 0xE4, 0x37, 0xF3, 0x60, 0xE2, 0xF2, 0xD7,
0xEB, 0x94, 0x1C, 0x74, 0x7F, 0xE5, 0x54, 0xE8,
0xA5, 0x32, 0x0A, 0xAF, 0x1E, 0x6D, 0x14, 0xD2,
0xE3, 0x85, 0xC1, 0xB1, 0xF4, 0x91, 0xB9, 0xF1,
0x5D, 0xDE, 0x54, 0x80, 0x9A, 0x30, 0xF2, 0xD7,
0x11, 0xDF, 0x9D, 0x4A, 0x40, 0x48, 0x68, 0x3B,
0xEB, 0x18, 0xA9, 0xBE, 0x35, 0x36, 0x85, 0xEE,
0x38, 0x02, 0x35, 0xC7, 0x43, 0xEF, 0xD3, 0xE0,
0xAE, 0x18, 0xE6, 0xF2, 0x6A, 0x3C, 0xE9, 0x6C,
0x78, 0x60, 0xE0, 0x5A, 0x3C, 0xC9, 0xA7, 0xB1,
0x3A, 0xC3, 0xDF, 0x61, 0x46, 0xC6, 0x3D, 0x4E,
0x72, 0x41, 0x45, 0x8B, 0x9F, 0x8E, 0x49, 0x85,
0xCB, 0xD1, 0xA4, 0x1D, 0x91, 0xCE, 0x6A, 0x21,
0x65, 0xAB, 0xC2, 0x51, 0x6F, 0x0F, 0xEF, 0xE8,
0x30, 0x29, 0xDB, 0xBF, 0xD4, 0xB1, 0x77, 0x9A,
0x62, 0xA9, 0x0B, 0xB1, 0xC0, 0x88, 0x29, 0x43,
0x24, 0xD5, 0xBA, 0x86, 0x3E, 0x57, 0x08, 0x70,
0x84, 0x5E, 0xF8, 0x1B, 0xD4, 0x83, 0xD6, 0x03,
0x69, 0xEC, 0x16, 0x7A, 0x83, 0xB1, 0x1B,
0xB4, 0x60, 0x0F, 0xA6, 0xFA, 0x2C, 0x42, 0xE7,
0x9C, 0xF8, 0xE1, 0x47, 0x55, 0x38, 0xFF, 0xF7,
0x98, 0x3E, 0x36, 0xFA, 0xF5, 0x6E, 0x69, 0x2F,
0xA2, 0xB8, 0x26, 0xDF, 0x37, 0x88, 0x7E, 0x49,
0x50, 0x58, 0xE8, 0x2B, 0x15, 0x2E, 0x1F, 0x6C,
0x11, 0xA5, 0x10, 0x99, 0x4A, 0xF4, 0xDA, 0xDC,
0x3D, 0x15, 0x51, 0x48, 0x72, 0x91, 0x26, 0xA1,
0xF4, 0x2D, 0x60, 0xED, 0xCC, 0x25, 0x50, 0xC7,
0xA8, 0x83, 0x19, 0x87, 0x89, 0x0F, 0x3D, 0x06,
0x95, 0xBB, 0x66, 0x8A, 0x29, 0xDE, 0xF1, 0x0D,
0xC6, 0x95, 0x15, 0x6E, 0xFE, 0x39, 0x2E, 0xA5,
0xB8, 0x0E, 0xA9, 0x61, 0x7E, 0xDB, 0x6F, 0x39,
0x44, 0x76, 0xC8, 0x04, 0xD6, 0x49, 0x5D, 0xF4,
0xE1, 0x5D, 0x58, 0x76, 0xC3, 0xCB, 0xCF, 0x52,
0x17, 0x1B, 0x24, 0x6C, 0x00, 0x09, 0x81, 0x73,
0x06, 0xE3, 0x96, 0x70, 0x86, 0xF9, 0xC4, 0x76,
0x5D, 0xE8, 0xDA, 0xB1, 0xC5, 0x3A, 0x44, 0x32,
0x3C, 0x55, 0x49, 0x93, 0x43, 0x24, 0xE1, 0x31,
0xC5, 0xB7, 0xA8, 0x99, 0xD5, 0x80, 0x46, 0x37,
0x96, 0x2E, 0x0C, 0x89, 0x1F, 0xA7, 0x6F, 0x75,
0x95, 0x65, 0x9F, 0xB3, 0xBF, 0xE0, 0x01, 0xFC,
0xCE, 0xF0, 0x42, 0x5C, 0x6D, 0xBF, 0x11, 0x0C,
0xBD, 0x39, 0xAE, 0x0F, 0x08, 0x65, 0xBB, 0x4D,
0x26, 0x5A, 0x99, 0x2A, 0xE1, 0x0C, 0xA2, 0xBC,
0x96, 0x77, 0x7B, 0xF5, 0x61, 0x23, 0xD7, 0x58,
0x45, 0x65, 0x6D, 0x11, 0xC0, 0xA6, 0xAA, 0x3F,
0x52, 0xE6, 0xAB, 0xF3, 0xAE, 0xFE, 0xAE, 0xF1,
0x83, 0x7D, 0x92, 0x58, 0x08, 0xAA, 0x79, 0xB6,
0x73, 0xA8, 0x04, 0xF7, 0x0E, 0x4B, 0xFA, 0xD2,
0x93, 0x05, 0x79, 0x0C, 0xBE, 0xA0, 0x38, 0x9F,
0x70, 0xA9, 0x7E, 0x38, 0x4C, 0x2B, 0x03, 0xD9,
0xAC, 0x22, 0x63, 0xFD, 0x78, 0xE8, 0x5F, 0x0F,
0xFB, 0x8B, 0x20, 0xD3, 0xCE, 0x51, 0x69, 0x8D,
0x27, 0xBD, 0x4F, 0x17, 0x13, 0xC9, 0x20, 0xA0,
0x09, 0x5A, 0x77, 0x9F, 0xAB, 0xC4, 0xA0, 0xDB,
0x90, 0xC4, 0x87, 0xE8, 0x80, 0x32, 0xDA, 0x12,
0x4C, 0xB2, 0xF1, 0x96, 0x1F, 0x1F, 0x71, 0x73,
0xD3, 0xD0, 0x37, 0x60, 0x9F, 0xC6, 0x2D, 0x07,
0x35, 0xA3, 0xB0, 0x56, 0xF4, 0x2F, 0xDC, 0x79,
0x08, 0xDB, 0xF4, 0xCB, 0xC5, 0x91, 0xB7, 0xEB,
0x72, 0x72, 0xAC, 0x40, 0xAF, 0x4F, 0x0F, 0x9A,
0xE4, 0xF8, 0xAF, 0x6E, 0x65, 0x61, 0xA1, 0xA9,
0x82, 0x03, 0xEA, 0x16, 0x12, 0x91, 0x4B, 0xB6,
0xB2, 0xE3, 0x56, 0x4B, 0xE9, 0xBF, 0x79, 0xDE,
0x64, 0xB5, 0x3C, 0x34, 0xFC, 0xB7, 0x55, 0x9E,
0x51, 0x29, 0x1C, 0x86, 0xBB, 0xCD, 0xBD, 0x42,
0x32, 0x34, 0x46, 0xCA, 0xD2, 0x41, 0xA0, 0x05,
0xF3, 0x09, 0xD0, 0x55, 0x72, 0x3F, 0xD9, 0x06,
0x41, 0x3E, 0xA7, 0x0A, 0x6E, 0xE5, 0xD7, 0x3F,
0xDC, 0xAD, 0xCC, 0x2D, 0xD3, 0x25, 0xD2, 0x69,
0xC6, 0xF9, 0x39, 0xAA, 0xDB, 0xBD, 0xD1, 0x71,
0xE2, 0xC3, 0x63, 0x40, 0x19, 0x7A, 0x6B, 0x46,
0xC9, 0x67, 0xB3, 0x09, 0x51, 0xF8, 0xB1, 0x68,
0xD8, 0xB0, 0xC9, 0xB0, 0x4B, 0x6F, 0x7D, 0x89,
0xF6, 0x8F, 0xD4, 0x9E, 0xC3, 0xF0, 0xB6, 0x36,
0xD0, 0xE3, 0xEF, 0x1D, 0xA2, 0x9A, 0x43, 0x9F,
0xE4, 0x06, 0x1E, 0x71, 0x87, 0xAF, 0xC6, 0xBF,
0x6A, 0x3E, 0xD4, 0x35, 0x09, 0xAC, 0x70, 0xD6,
0x74,
0x30, 0x7B, 0xBB, 0x73, 0xFF, 0xF2, 0x10, 0xF4,
0xAA, 0x9F, 0xF2, 0x47, 0xF2, 0xC6, 0x2C, 0x7B,
0x72, 0x9E, 0x46, 0xA2, 0x7C, 0x1A, 0xBE, 0x96,
0x09, 0xD6, 0x44, 0xA2, 0x8C, 0x1C, 0x2C, 0x58,
0xB2, 0xCF, 0x04, 0xA0, 0xA6, 0x45, 0xBD, 0x8F,
0xCA, 0x7E, 0xE5, 0xCA, 0x7E, 0x5A, 0x78, 0x55,
0xF4, 0xF5, 0x64, 0xEC, 0xAC, 0x7F, 0x3E, 0x33,
0xF8, 0xE4, 0x02, 0x0D, 0x2D, 0xC5, 0x89, 0xFF,
0x82, 0xB3, 0x16, 0xD5, 0x2F, 0xDF, 0x7B, 0x23,
0x99, 0x38, 0xB2, 0x2B, 0xF9, 0x6B, 0x75, 0x64,
0x8E, 0x4A, 0xAE, 0x2C, 0xA3, 0x92, 0x2A, 0xF2,
0x5C, 0x9B, 0x4D, 0x07, 0x1E, 0x39, 0x5F, 0x39,
0x50, 0x7E, 0x9D, 0xC0, 0xBB, 0xBD, 0x2D, 0xA4,
0xE7, 0x8E, 0x3C, 0xCB, 0xA1, 0x5A, 0xA1, 0x30,
0x1D, 0xC8, 0x1C, 0x16, 0x09, 0x20, 0x6A, 0x8E,
0xD8, 0xDC, 0x79, 0xC3, 0xFA, 0xC4, 0x7D, 0x31,
0x8E, 0xC1, 0x02, 0x7C, 0xB0, 0x75, 0xE4, 0x36,
0xA0, 0x90, 0x0B, 0x9E, 0x0F, 0xB1, 0xF4, 0xAA,
0xA1, 0x05, 0x3E, 0x85, 0x02, 0xDC, 0xE5, 0xD8,
0xC2, 0x7E, 0x49, 0xD5, 0x76, 0x06, 0x09, 0xA5,
0x2C, 0x81, 0x20, 0x79, 0xD2, 0x92, 0x25, 0xBC,
0x8B, 0xDA, 0x4A, 0xC5, 0x09, 0xA7, 0x1D, 0xC5,
0x3A, 0xBD, 0x5D, 0x19, 0x53, 0x8D, 0x49, 0xFD,
0x65, 0xFA, 0x8A, 0xBB, 0xFF, 0xF1, 0x99, 0xE5,
0x5D, 0x9F, 0x30, 0x23, 0xB5, 0x58, 0x9E, 0x30,
0x38, 0x59, 0xCD, 0x20, 0x7D, 0x69, 0x5A, 0x74,
0xD1, 0x6D, 0x3C, 0xED, 0x34, 0x5A, 0x6F, 0xC1,
0xD4, 0x45, 0x4C, 0xE2, 0xE2, 0x31, 0x8F, 0x96,
0x75, 0xBE, 0x6E, 0xF9, 0x75, 0x99, 0x06, 0x84,
0x5F, 0x36,
0xBD, 0xBD, 0xED, 0x66, 0xF7, 0x17, 0xCC, 0x7A,
0x14, 0xB5, 0x83, 0x83, 0xBA, 0xC0, 0x96, 0x7D,
0x97, 0x36, 0x62, 0x80, 0x72, 0x5B, 0x84, 0xC8,
0x65, 0xF4, 0x18, 0xEC, 0x1C, 0xFC, 0x37, 0x18,
0x40, 0x26, 0x64, 0x0E, 0xF8, 0xA8, 0x66, 0x3C,
0x94, 0x0C, 0x98, 0xAE, 0x6B, 0x71, 0x74, 0xAC,
0x75, 0x11, 0x39, 0xDA, 0x27, 0x87, 0xB9, 0x8D,
0xAA, 0x0A, 0xE0, 0xB5, 0x25, 0x9F, 0xB5, 0x36,
0xC9, 0x3A, 0x91, 0x98, 0x2B, 0xB5, 0xDF, 0x68,
0x56, 0x84, 0x48, 0xB3, 0xCC, 0x2E, 0x50, 0x21,
0x15, 0x7B, 0xFF, 0x96, 0xB8, 0x1E, 0xC7, 0xCE,
0x8E, 0xD4, 0x51, 0x42, 0x65, 0x26, 0x38, 0xC1,
0x9A, 0x47, 0x52, 0x15, 0x16, 0x2E, 0x44, 0x03,
0xE8, 0x45, 0x9B, 0x64, 0x1F, 0xC8, 0x3C, 0x59,
0xA9, 0x7B, 0xBB, 0x09, 0xC2, 0x3D, 0x12, 0x94,
0x0F, 0xFC, 0xB2, 0x1A, 0x95, 0x0A, 0x83, 0x77,
0x82, 0xCC, 0x31, 0xBD, 0x75, 0xC3, 0x56, 0x87,
0xBA, 0x3F, 0x36, 0x44, 0xF5, 0x89, 0x19, 0x5B,
0x00, 0xA5, 0xE6, 0x41, 0x8B, 0x23, 0x81, 0x8B,
0x01, 0xBC, 0xCE, 0xE2, 0x58, 0x7A, 0x74, 0x02,
0xA2, 0x61, 0xB1, 0x6A, 0x42, 0xA0, 0xB4, 0x2E,
0x5B, 0x16, 0x1B, 0xB9, 0xC3, 0x3B, 0x1E, 0x89,
0x6B, 0xC3, 0x08, 0x16, 0x26, 0xE2, 0x75, 0x48,
0x29, 0xBA, 0x7C, 0xC2, 0x6D, 0x67, 0x58, 0xF3,
0xD3, 0xD1, 0x3B, 0x1D, 0xA1, 0x62, 0x52, 0x37,
0x96, 0xC7, 0x9D, 0xA0, 0xCE, 0x78, 0xB6, 0x9E,
0x97, 0x88, 0x59, 0xFC, 0x26, 0x45, 0x6D, 0x46,
0x5C, 0x39, 0xCD, 0xE5, 0x19, 0x26, 0x70, 0x3C,
0x70, 0x14, 0x85, 0x73, 0xC3, 0x41, 0xD5, 0x27,
0xA6, 0x3B, 0x8D,
0x20, 0xE0, 0x97, 0x10, 0x4E, 0x18, 0x60, 0xE9,
0x94, 0xC5, 0x03, 0x98, 0xF2, 0xA9, 0x43, 0x9F,
0xBD, 0x6C, 0xC8, 0xBB, 0x53, 0xEC, 0xD4, 0x8D,
0xE7, 0x26, 0x31, 0xC9, 0xF4, 0x1F, 0xD7, 0x09,
0xCB, 0x87, 0x13, 0x90, 0xAF, 0x18, 0x42, 0xF3,
0xB4, 0x22, 0x93, 0x00, 0xD0, 0x56, 0x36, 0x7C,
0xED, 0x4F, 0x0E, 0xB9, 0xD4, 0xA6, 0xEE, 0xAB,
0x42, 0x0D, 0x1D, 0xDD, 0xE2, 0x9C, 0x49, 0xBC,
0x78, 0xBA, 0xDF, 0x72, 0x6B, 0xC2, 0x2D, 0xE0,
0x7C, 0xC2, 0x02, 0x61, 0xAA, 0x7C, 0x43, 0x38,
0xB4, 0x28, 0xF4, 0x73, 0xF2, 0x6B, 0xDA, 0xA6,
0x08, 0x12, 0x9E, 0xEF, 0x3E, 0xC4, 0xA5, 0x75,
0x01, 0x1A, 0xEE, 0x77, 0x5D, 0xAA, 0x3A, 0x40,
0xFC, 0x2C, 0x3E, 0x2C, 0xBD, 0x19, 0x1D, 0x9D,
0x08, 0x88, 0x9D, 0xF7, 0x52, 0x60, 0xB5, 0x6B,
0x1D, 0x63, 0x64, 0xEF, 0xBC, 0x36, 0x85, 0x42,
0xFF, 0xBF, 0x15, 0x5D, 0x29, 0xEE, 0x75, 0x2B,
0x38, 0xD2, 0x35, 0x4F, 0xA0, 0x14, 0xE6, 0xC7,
0x85, 0x2F, 0xE6, 0xC0, 0x22, 0x28, 0xDA, 0xAE,
0x13, 0x5C, 0x06, 0x23, 0x81, 0xC5, 0x3E, 0x49,
0xBF, 0x3D, 0xEF, 0xD7, 0x32, 0xBE, 0xEB, 0x49,
0x66, 0x60, 0x14, 0xAD, 0x8A, 0xE9, 0x83, 0x0C,
0x23, 0x33, 0x49, 0x1B, 0x2E, 0x77, 0xF3, 0x15,
0x55, 0xBA, 0xC8, 0xA9, 0xF3, 0xAC, 0x97, 0xA9,
0x99, 0x31, 0x73, 0x4D, 0x65, 0x2F, 0xA9, 0x20,
0x2F, 0x40, 0x67, 0x80, 0x21, 0xBE, 0x9F, 0x59,
0x4A, 0x64, 0x10, 0x1A, 0x65, 0xA0, 0x37, 0x3B,
0x4F, 0x8C, 0xCD, 0xBF, 0x02, 0x04, 0xDC, 0x0D,
0xAE, 0xB5, 0xF5, 0x5E, 0xB7, 0x87, 0x32, 0x73,
0xF3, 0x01, 0xDD, 0x68,
0x96, 0x71, 0x89, 0xE4, 0xEC, 0x66, 0xCF, 0x80,
0xFF, 0xC3, 0x5B, 0xA8, 0x2F, 0xBA, 0x62, 0xD0,
0xA5, 0x46, 0xB0, 0xA7, 0x7C, 0x5B, 0x6F, 0x7D,
0x8F, 0xA2, 0x4B, 0x67, 0xE9, 0xAF, 0x14, 0x2E,
0x43, 0xB8, 0xD0, 0x13, 0x78, 0x78, 0xB5, 0x75,
0x80, 0x0C, 0xC2, 0xA0, 0x4C, 0x62, 0xB3, 0xC8,
0x7E, 0xA9, 0x12, 0xD0, 0xD7, 0x05, 0xD8, 0x0E,
0x78, 0xA3, 0x1F, 0x60, 0x0B, 0x28, 0xB9, 0x2A,
0x00, 0x80, 0xB5, 0x1C, 0xA0, 0xDC, 0x82, 0xC6,
0x37, 0x93, 0x21, 0x5E, 0x06, 0x6F, 0x34, 0xA5,
0xB2, 0x92, 0x8D, 0xC4, 0xD7, 0xF4, 0x98, 0xB9,
0x6D, 0x9A, 0xC8, 0x55, 0x6E, 0x33, 0xD2, 0x17,
0x60, 0xB8, 0xD0, 0xC3, 0x85, 0x67, 0x5B, 0x37,
0x4D, 0xAF, 0x22, 0x5A, 0x45, 0x3C, 0x4E, 0x8D,
0x8D, 0x6B, 0x70, 0x5A, 0xC6, 0xEE, 0xF9, 0x71,
0xA1, 0x75, 0xED, 0x02, 0xBF, 0xCB, 0xF9, 0xFE,
0x49, 0xB4, 0x48, 0xFC, 0x5B, 0xCC, 0x2F, 0x7D,
0x9E, 0x6D, 0x34, 0xC6, 0x6F, 0xE6, 0x76, 0xB6,
0x3A, 0xB6, 0x43, 0x69, 0x86, 0x88, 0x69, 0x30,
0x06, 0xA9, 0x2B, 0x25, 0x4D, 0xAF, 0x43, 0x6C,
0xFF, 0x1F, 0x7C, 0x2B, 0x09, 0xFA, 0x42, 0x15,
0x3A, 0x87, 0x6F, 0x8C, 0xC6, 0x59, 0x5D, 0x74,
0x04, 0xA0, 0xA9, 0x36, 0xF2, 0x47, 0x67, 0x71,
0x7D, 0x81, 0x19, 0x0C, 0xC4, 0x1E, 0xC5, 0x59,
0x8F, 0xB5, 0xAF, 0x44, 0x5C, 0xE4, 0x5A, 0xCC,
0xD4, 0xEA, 0x99, 0x39, 0xD9, 0xBE, 0x73, 0x90,
0x3C, 0x5B, 0x1C, 0xDF, 0xEF, 0x17, 0x7D, 0x3A,
0x98, 0x3A, 0xDF, 0xD5, 0xCC, 0xD3, 0x4A, 0xBE,
0xC0, 0x56, 0xB3, 0x1C, 0xCC, 0x57, 0xDB, 0xFE,
0xFA, 0x5B, 0x9C, 0x1A, 0x76,
0x2C, 0xFE, 0x9A, 0xA9, 0x43, 0x0E, 0x02, 0xD1,
0x24, 0x54, 0x00, 0x7B, 0xFD, 0x2A, 0x66, 0x10,
0xCA, 0xA4, 0xE4, 0xA5, 0xD2, 0x57, 0x48, 0xA5,
0x39, 0x7E, 0x2B, 0xCE, 0xAD, 0x40, 0x3A, 0xE6,
0x00, 0x54, 0xDE, 0xC3, 0x8D, 0x0F, 0x2D, 0x0B,
0x0B, 0x47, 0x45, 0x2A, 0x92, 0x35, 0x23, 0xE0,
0xB4, 0xB4, 0xFA, 0xCD, 0x5F, 0x86, 0x90, 0x48,
0x70, 0xE9, 0xD8, 0x1C, 0xEE, 0x1B, 0x9B, 0xFA,
0xC4, 0xC8, 0xA1, 0xF5, 0x00, 0x6D, 0x94, 0xD7,
0xE8, 0xF3, 0xB1, 0xDA, 0x64, 0x1C, 0x16, 0x40,
0xD4, 0xB4, 0x97, 0xFD, 0x24, 0x06, 0x88, 0xEE,
0xD3, 0x71, 0x64, 0x52, 0x82, 0xB0, 0xE0, 0xF4,
0xEC, 0xCB, 0x47, 0x60, 0xB1, 0x17, 0xD7, 0xBC,
0x6E, 0x49, 0x04, 0xE1, 0x21, 0x49, 0xA8, 0x1C,
0xC4, 0x1D, 0xB6, 0x5A, 0x70, 0xA5, 0x60, 0xA3,
0x87, 0xC6, 0x5E, 0x4F, 0xFB, 0xDD, 0x1A, 0x0A,
0x18, 0x4A, 0x41, 0xDC, 0x24, 0x3F, 0x47, 0x6E,
0x48, 0x1F, 0x10, 0x66, 0x10, 0x0A, 0xC3, 0xFA,
0x59, 0x0E, 0xC6, 0xB9, 0x4B, 0x9A, 0x42, 0xDC,
0xE9, 0x0F, 0xCB, 0x0E, 0x08, 0xB0, 0x06, 0x73,
0x36, 0x86, 0x27, 0x73, 0x90, 0xB2, 0xD1, 0x0D,
0x8F, 0x35, 0xCF, 0xB9, 0x0C, 0xFE, 0xF1, 0x47,
0x08, 0x41, 0x3E, 0x4D, 0x56, 0x90, 0x1E, 0xAC,
0x8C, 0x9D, 0xEE, 0x38, 0x45, 0x64, 0x12, 0x8A,
0xB4, 0x1B, 0xA2, 0x9F, 0xA2, 0xE0, 0xC6, 0xE9,
0x40, 0x1B, 0xCA, 0x86, 0xDB, 0x1F, 0x96, 0x4D,
0x0B, 0x83, 0xE2, 0xAA, 0x90, 0xD2, 0x72, 0x3F,
0xC3, 0xBF, 0x94, 0xFA, 0xDB, 0xA6, 0x49, 0x51,
0x8C, 0xF3, 0x2A, 0x07, 0xFB, 0xCE, 0x9C, 0x29,
0xB2, 0x00, 0x3C, 0xB8, 0xBF, 0x58,
0xDF, 0x48, 0x90, 0xC4, 0x10, 0xDB, 0x2D, 0x0E,
0x0C, 0x33, 0x30, 0xD3, 0x07, 0x67, 0xC1, 0x0B,
0xBC, 0xE3, 0x60, 0xCB, 0x88, 0x90, 0x72, 0xE5,
0x75, 0x49, 0xE9, 0x07, 0xBA, 0x87, 0xB2, 0x13,
0xBA, 0x15, 0x1D, 0x6D, 0xBB, 0x64, 0x18, 0x3A,
0x13, 0x56, 0x30, 0x5D, 0x2F, 0xDC, 0xC9, 0x18,
0x04, 0xE2, 0xEC, 0xF9, 0x75, 0xED, 0x47, 0x0C,
0xDA, 0x11, 0x5A, 0x9A, 0x60, 0xED, 0x9F, 0x27,
0x20, 0x31, 0xE3, 0xF6, 0x97, 0x52, 0x4A, 0x7E,
0x26, 0xF3, 0x3C, 0x66, 0x66, 0x7F, 0x96, 0xE3,
0xD2, 0x16, 0xB6, 0x68, 0xF4, 0x02, 0x82, 0xC4,
0xDC, 0x2F, 0xBD, 0x13, 0xF0, 0xAA, 0x2F, 0x89,
0xBB, 0x7D, 0xC5, 0x73, 0xBE, 0xCF, 0xBB, 0xFA,
0x5D, 0xDE, 0x61, 0xFD, 0x75, 0x76, 0x4F, 0xBA,
0xDA, 0x87, 0x69, 0x76, 0x83, 0x71, 0x5E, 0xE0,
0xD9, 0x4F, 0x30, 0xB9, 0x14, 0x4B, 0x48, 0x72,
0xF7, 0xD4, 0x6C, 0x15, 0x51, 0x51, 0x35, 0xB4,
0x00, 0x77, 0x9C, 0x54, 0xCE, 0x62, 0x0B, 0x5F,
0x88, 0x48, 0xC1, 0x80, 0x00, 0xD3, 0x58, 0x1D,
0x23, 0xE6, 0x3F, 0xA5, 0xB9, 0x5A, 0x83, 0x46,
0x58, 0xA1, 0x6E, 0x67, 0x20, 0xF9, 0xA3, 0x36,
0xC4, 0x00, 0x14, 0xB9, 0x42, 0xDA, 0x89, 0x60,
0xEB, 0x59, 0x41, 0x34, 0x5D, 0xAC, 0x15, 0x19,
0x9D, 0x81, 0xD2, 0x2A, 0x18, 0x63, 0x27, 0x9E,
0xBF, 0xE1, 0xBD, 0xB3, 0x70, 0xEB, 0xAA, 0xCD,
0xAB, 0x41, 0xEC, 0x97, 0x49, 0x6D, 0x51, 0xB1,
0x80, 0xA5, 0x13, 0xD0, 0x1B, 0x2E, 0x70, 0x46,
0x17, 0xB1, 0x23, 0xD2, 0x8A, 0x85, 0xA7, 0x21,
0x95, 0x71, 0xC2, 0x92, 0x0C, 0xC1, 0xDC, 0xB7,
0x07, 0x6A, 0x3A, 0x8F, 0x84, 0xEC, 0x33,
0xC8, 0xF4, 0xAC, 0xDE, 0x46, 0xD4, 0x1E, 0xD4,
0xF9, 0x02, 0x7A, 0x07, 0x56, 0x2C, 0x5C, 0xCA,
0xCA, 0xAF, 0xBD, 0xD7, 0x26, 0x3C, 0x92, 0x93,
0x4C, 0x49, 0x1D, 0x24, 0xC5, 0x33, 0x6F, 0x25,
0xD5, 0xCB, 0x99, 0xD1, 0x77, 0x62, 0x4C, 0x5F,
0xC2, 0x5C, 0x14, 0x6C, 0xD0, 0xC9, 0x8C, 0xCE,
0x8F, 0x7D, 0x2F, 0x4A, 0x72, 0xF4, 0xED, 0xC9,
0xD6, 0x9F, 0x09, 0xB7, 0x8E, 0xCE, 0x4B, 0x97,
0x95, 0xAE, 0x30, 0xFF, 0xF9, 0x54, 0x6E, 0xDE,
0x33, 0x66, 0x11, 0x55, 0x9E, 0x98, 0x00, 0xA4,
0x92, 0x5E, 0x00, 0x09, 0x3E, 0x9E, 0x50, 0xA3,
0xA1, 0xAE, 0x57, 0xF9, 0x91, 0xC8, 0x48, 0x50,
0x92, 0xAE, 0x5A, 0x7E, 0x2F, 0x98, 0xCC, 0xBD,
0x05, 0x64, 0x17, 0x3E, 0xF4, 0x87, 0xCE, 0xD5,
0x92, 0xE9, 0x7F, 0xF2, 0xB0, 0xDB, 0x72, 0x79,
0x20, 0x90, 0x43, 0xDB, 0x1A, 0x75, 0x7A, 0x00,
0xC9, 0x4E, 0xD6, 0xF4, 0x37, 0x5D, 0x87, 0xA6,
0xF5, 0x73, 0x01, 0xC0, 0x44, 0xB2, 0x60, 0x82,
0x72, 0x92, 0x6C, 0x75, 0x50, 0xEF, 0x76, 0xEA,
0xC4, 0x70, 0xD8, 0x92, 0x50, 0xA9, 0x52, 0x08,
0xDB, 0xBD, 0x69, 0x9B, 0xAF, 0x19, 0x7E, 0x8D,
0x14, 0xCA, 0x37, 0xB7, 0x82, 0x22, 0x21, 0x62,
0x9D, 0xEF, 0x2B, 0x78, 0x0B, 0x73, 0x9E, 0x98,
0xFC, 0xF0, 0x90, 0xCE, 0x34, 0xF7, 0x04, 0xC0,
0x5B, 0x1E, 0x27, 0xBA, 0xB6, 0xD2, 0xDD, 0x34,
0xCD, 0xDA, 0x99, 0x94, 0xA5, 0xA3, 0xFE, 0x4B,
0xB6, 0x87, 0x5D, 0xD1, 0x78, 0x00, 0x54, 0xC3,
0x00, 0x1D, 0x92, 0x9E, 0xD2, 0xD9, 0x92, 0x71,
0xC4, 0x8C, 0xA4, 0x58, 0xB9, 0xC4, 0x86, 0x21,
0x6F, 0x9A, 0x23, 0x6D, 0x80, 0xF1, 0x7E, 0x8C,
0x5D, 0x86, 0x96, 0xBC, 0xEA, 0xB5, 0x3B, 0x00,
0xC1, 0xFC, 0x22, 0xF0, 0x5F, 0x3D, 0x1E, 0x6B,
0x10, 0x0A, 0xE0, 0xB9, 0x3A, 0x52, 0x08, 0x25,
0x05, 0x6E, 0xA9, 0x19, 0x26, 0x36, 0x64, 0x3D,
0x3B, 0xA5, 0xBD, 0xBA, 0x3C, 0x71, 0xAE, 0x3B,
0x85, 0x37, 0x18, 0xCB, 0xC4, 0x62, 0x1D, 0xEA,
0x54, 0x47, 0xB2, 0xDC, 0x78, 0x98, 0x10, 0x22,
0xB4, 0xB8, 0xFD, 0xA2, 0x4C, 0x79, 0x16, 0xE7,
0x8C, 0x7B, 0xA3, 0x22, 0x2B, 0x8E, 0x9A, 0x9C,
0x0E, 0x7A, 0x64, 0xBD, 0x3B, 0x48, 0xAD, 0x8E,
0x7A, 0xBC, 0x55, 0xB6, 0x0A, 0x8C, 0xFD, 0x88,
0x83, 0xA6, 0x21, 0xC8, 0x4E, 0x9A, 0x2A, 0x97,
0xCC, 0x38, 0xA9, 0xD9, 0xD5, 0x5B, 0x38, 0xB4,
0x3D, 0xFB, 0xFB, 0x5C, 0x5B, 0xB6, 0x1B, 0x04,
0x02, 0xDB, 0x9B, 0x48, 0x4E, 0xE6, 0x46, 0x46,
0xDF, 0x9A, 0x80, 0x0B, 0x36, 0xA4, 0xBE, 0x66,
0x4A, 0x8C, 0xDC, 0xD7, 0xB8, 0x74, 0x88, 0x21,
0x79, 0x56, 0x25, 0x73, 0x61, 0xD2, 0xEC, 0x80,
0x7B, 0x4F, 0xF6, 0x1E, 0xFA, 0x44, 0x07, 0x14,
0x80, 0xD0, 0x1F, 0xCB, 0x70, 0xDC, 0x66, 0x36,
0xA2, 0xA9, 0x77, 0x45, 0x24, 0x60, 0xF4, 0xA2,
0x72, 0xF6, 0xE5, 0x57, 0x76, 0x58, 0x1A, 0x18,
0x17, 0xD6, 0x34, 0xAF, 0x61, 0xD4, 0x07, 0xBD,
0x5D, 0x18, 0xCF, 0x6B, 0x36, 0xAF, 0xD8, 0xC0,
0xAF, 0x0C, 0x2A, 0x3D, 0x93, 0x04, 0xCE, 0x50,
0xD8, 0x9E, 0xAE, 0x81, 0x80, 0xF6, 0xE9, 0xA4,
0xFB, 0xAE, 0xB6, 0x15, 0xC7, 0xC2, 0x8D, 0x49,
0x5F, 0x94, 0x8E, 0x9A, 0x32, 0x07, 0x0E, 0x77,
0x1D, 0x46, 0xD6, 0x55, 0x97, 0xFE, 0xBA, 0x0E,
0xCC, 0xF8, 0x84, 0x09, 0x84, 0x0C, 0x2D, 0xA9,
0xD6,
0x53, 0x72, 0xC8, 0x2C, 0xF6, 0x4A, 0xB5, 0xB2,
0x05, 0x3D, 0x71, 0x41, 0x8E, 0x40, 0xC4, 0x22,
0x50, 0x31, 0x1B, 0xBA, 0x3F, 0xCA, 0xB7, 0xBE,
0x83, 0x4B, 0x8B, 0x36, 0xC1, 0x9B, 0xA1, 0xE9,
0xA9, 0x5D, 0x5E, 0xD2, 0x03, 0xEA, 0x1E, 0xD2,
0x89, 0xE6, 0x90, 0xA7, 0x25, 0x2E, 0xE6, 0x95,
0x2B, 0x49, 0x06, 0xAF, 0x29, 0x78, 0xA5, 0x5B,
0x29, 0xDA, 0x9F, 0xE6, 0x45, 0xC4, 0x36, 0xDA,
0xCC, 0xDF, 0xF7, 0xA2, 0x4C, 0xFD, 0xCF, 0xC4,
0xB7, 0x1F, 0x3C, 0x62, 0x6C, 0x05, 0x05, 0x94,
0x1E, 0xE4, 0xC0, 0xCE, 0x3D, 0x26, 0x9A, 0xE2,
0xDA, 0xF5, 0x7C, 0xEC, 0x49, 0x49, 0x38, 0xF5,
0x54, 0xFD, 0x7F, 0xA2, 0xA9, 0x4F, 0x3E, 0xA8,
0xBC, 0x79, 0x94, 0xD7, 0x28, 0x86, 0x44, 0x45,
0xE7, 0x06, 0x86, 0xA7, 0x5B, 0x00, 0xF8, 0xC3,
0xDA, 0xC7, 0x7E, 0xA7, 0x42, 0xB0, 0xAA, 0xD5,
0x28, 0x97, 0xB0, 0xC4, 0x41, 0x7F, 0xBF, 0xD2,
0xF5, 0xEF, 0x08, 0x92, 0xC7, 0x21, 0xA8, 0x2E,
0x37, 0xF7, 0x99, 0x35, 0x53, 0x07, 0xFE, 0x21,
0xFE, 0x6B, 0xA1, 0xD0, 0x01, 0x0D, 0x23, 0x45,
0x68, 0x8D, 0xE2, 0x30, 0xE0, 0x94, 0x5B, 0x1D,
0xD2, 0xE5, 0x6A, 0xCB, 0xC2, 0xE7, 0xB0, 0xD7,
0x7F, 0x52, 0xA7, 0x9A, 0x3A, 0x3B, 0xA6, 0x7C,
0x82, 0x01, 0xE3, 0x0D, 0x03, 0xBE, 0x1D, 0x37,
0xA9, 0x88, 0x1A, 0xC8, 0x61, 0xD3, 0x51, 0xAE,
0xCD, 0xA0, 0x3C, 0x3D, 0x35, 0x89, 0xE2, 0x4C,
0x8A, 0xAB, 0xA7, 0x21, 0x6B, 0xB5, 0xA5, 0x9E,
0xF1, 0xA9, 0x8B, 0x9C, 0x01, 0x2A, 0x6A, 0x6B,
0xAE, 0x7B, 0x2E, 0xDB, 0x2B, 0xA9, 0x77, 0x5E,
0xD1, 0x85, 0xF6, 0xB8, 0x55, 0xD3, 0x59, 0x98,
0x61, 0x8D,
0xD3, 0xB1, 0xA7, 0x9B, 0xE7, 0x58, 0x9B, 0xF8,
0x74, 0x55, 0xAE, 0xA5, 0x41, 0x14, 0xE8, 0x64,
0x31, 0xC2, 0x92, 0xD1, 0x96, 0x27, 0x7A, 0xA6,
0x80, 0x26, 0x53, 0xB9, 0xDF, 0x80, 0xB6, 0x21,
0xC2, 0x4A, 0x98, 0x48, 0x49, 0xF9, 0x67, 0x5A,
0x01, 0x8A, 0x10, 0xAB, 0xEB, 0xA0, 0x73, 0x9B,
0x2F, 0x2B, 0x07, 0x08, 0x49, 0x36, 0x01, 0xF1,
0x17, 0xE3, 0x3A, 0xDF, 0x90, 0xE1, 0x75, 0x83,
0x4E, 0xE4, 0x92, 0x54, 0x6A, 0xE9, 0xB7, 0x5E,
0x99, 0x08, 0xA7, 0xF1, 0x06, 0x33, 0xD6, 0x1C,
0xD9, 0xF2, 0xBF, 0x5B, 0x49, 0xED, 0x37, 0x1A,
0x49, 0xF7, 0x37, 0xE5, 0x91, 0xAB, 0x8B, 0xE3,
0x48, 0xD0, 0x06, 0x14, 0x3A, 0x9F, 0x4F, 0xCE,
0x4A, 0xDD, 0x3A, 0x40, 0x0A, 0x57, 0x11, 0xD6,
0xB8, 0xCE, 0x21, 0xFB, 0x83, 0xFB, 0x5F, 0x1D,
0x04, 0xB5, 0x5F, 0x45, 0xB4, 0x41, 0xF0, 0x15,
0xF2, 0x3A, 0xCE, 0x80, 0x19, 0xDD, 0x77, 0x5E,
0xA1, 0x91, 0x4E, 0x38, 0x60, 0x15, 0x0C, 0xCF,
0x02, 0xAD, 0xD9, 0x88, 0x8F, 0x52, 0x06, 0xFD,
0x77, 0x20, 0x09, 0x75, 0xD6, 0x99, 0xAE, 0xFD,
0x23, 0xF5, 0x31, 0xD9, 0xB1, 0xED, 0x97, 0xDD,
0x45, 0x11, 0x13, 0x47, 0x1B, 0xB1, 0xBA, 0xDF,
0x31, 0xE2, 0xE8, 0x27, 0xD4, 0xD7, 0x72, 0x32,
0x28, 0x61, 0x31, 0x30, 0x02, 0xAA, 0x83, 0x1C,
0x71, 0xBE, 0xE0, 0xBE, 0x67, 0x49, 0xDB, 0x5C,
0x0D, 0x21, 0x45, 0x2B, 0xE3, 0x7F, 0x54, 0x31,
0x68, 0x0F, 0x62, 0xC8, 0xA2, 0xDA, 0x0F, 0x26,
0xA0, 0xB5, 0xB1, 0xF4, 0xDC, 0xDC, 0x5D, 0x3E,
0xEA, 0x68, 0x8A, 0xFF, 0xFA, 0xC9, 0xF5, 0x67,
0x61, 0x97, 0x39, 0xAE, 0xBF, 0xB8, 0xA9, 0x03,
0xA0, 0x96, 0x50,
0x1F, 0xC9, 0xF1, 0x2E, 0x74, 0x0D, 0x02, 0x1A,
0x21, 0xCD, 0xBA, 0xCB, 0x5D, 0x97, 0xD9, 0xE3,
0x96, 0x90, 0xDB, 0x29, 0x5D, 0x45, 0x4E, 0x58,
0x07, 0x81, 0xDA, 0xBE, 0x37, 0xEA, 0x4B, 0x98,
0x88, 0xBC, 0xE9, 0xBA, 0xAF, 0x8F, 0xA3, 0xF5,
0x8B, 0x78, 0x21, 0x21, 0x2C, 0x05, 0x79, 0x72,
0xE3, 0x12, 0x12, 0x49, 0xCF, 0x45, 0x81, 0x37,
0x96, 0x9A, 0xFF, 0xBC, 0xAA, 0x79, 0x22, 0x40,
0x01, 0x01, 0xA2, 0xCE, 0xEA, 0x11, 0x1E, 0x55,
0xB5, 0xAB, 0x91, 0xD0, 0xBA, 0x49, 0xA2, 0x07,
0xA2, 0xFB, 0x59, 0x50, 0xF1, 0x95, 0x43, 0xFB,
0xEE, 0xC0, 0x2A, 0xD7, 0xEB, 0x67, 0x51, 0x9B,
0x13, 0x3A, 0x17, 0xF0, 0x3B, 0xC6, 0x67, 0x00,
0xE7, 0x40, 0xAA, 0x74, 0xCD, 0x90, 0x2A, 0xCD,
0x3C, 0x48, 0x70, 0x0E, 0x80, 0x28, 0x36, 0xA1,
0x34, 0xF4, 0xB9, 0xE2, 0x34, 0x0A, 0x1B, 0x85,
0x8C, 0x91, 0x54, 0xCE, 0xB1, 0x32, 0x9D, 0x0D,
0x42, 0xC0, 0x94, 0x5C, 0x35, 0x9A, 0x41, 0x6D,
0x95, 0xAF, 0x7E, 0xD1, 0x4F, 0xE2, 0x3F, 0xBC,
0xA1, 0x18, 0x97, 0x35, 0xBA, 0x1A, 0x55, 0x04,
0x05, 0x71, 0xB3, 0x31, 0x47, 0x16, 0xA7, 0x3B,
0x4B, 0x7C, 0x6F, 0x5D, 0x76, 0x30, 0xAC, 0x6D,
0x0C, 0x8A, 0x93, 0x38, 0xEE, 0x19, 0x2B, 0x5E,
0x86, 0x4E, 0x48, 0xC1, 0x9C, 0x62, 0x0B, 0x4F,
0xC7, 0x62, 0xCD, 0xEF, 0x3C, 0xED, 0x93, 0x99,
0xD5, 0xC4, 0xF8, 0x33, 0x19, 0xCA, 0xE9, 0x24,
0x71, 0xAC, 0x38, 0x1C, 0x3A, 0x3E, 0xEF, 0xAB,
0x5F, 0x7D, 0xD6, 0xBF, 0x0E, 0x1D, 0x0C, 0xE7,
0x3E, 0xC8, 0xD6, 0x31, 0xE1, 0xF8, 0x8A, 0x24,
0x30, 0xD6, 0x28, 0x6E, 0xE9, 0xCC, 0x26, 0xE4,
0xE1, 0x46, 0xD7, 0x31,
0x64, 0x83, 0xDD, 0x30, 0x59, 0x47, 0x4F, 0x9D,
0xD4, 0xE1, 0x4D, 0x77, 0xB7, 0xCD, 0x73, 0x3E,
0xD3, 0x86, 0xD5, 0x73, 0x77, 0xB0, 0x0D, 0xDF,
0x8F, 0xF9, 0x5D, 0x6D, 0x52, 0xDD, 0xAA, 0x0E,
0x23, 0x38, 0xC5, 0xE8, 0xA7, 0x2D, 0x10, 0x1D,
0x7B, 0x6C, 0xF7, 0xEB, 0xD9, 0xC1, 0x71, 0x18,
0xDA, 0x50, 0xD6, 0x42, 0x31, 0x9D, 0xBE, 0x96,
0x01, 0x40, 0xF9, 0xDC, 0x05, 0x19, 0xDD, 0x76,
0x87, 0xEA, 0x0A, 0xF2, 0xBE, 0xA4, 0x96, 0x57,
0x24, 0x3E, 0x18, 0x2F, 0x2A, 0xF6, 0xAB, 0x0C,
0x08, 0xF0, 0xBA, 0xA0, 0x61, 0xE1, 0xD5, 0xFE,
0xF6, 0x12, 0x8F, 0xEF, 0xB2, 0xB4, 0xC8, 0x9F,
0x6C, 0xC4, 0xB4, 0xCE, 0x8C, 0x79, 0xCC, 0x32,
0x9A, 0xD3, 0x98, 0x12, 0x03, 0xB0, 0xD7, 0x15,
0x60, 0x90, 0xE1, 0x84, 0x5E, 0xE4, 0xEC, 0x07,
0x79, 0x78, 0x2D, 0xCB, 0x80, 0x71, 0x5D, 0xEC,
0x94, 0x75, 0x25, 0x00, 0xF4, 0x33, 0x43, 0x75,
0x67, 0xA8, 0x6B, 0x29, 0xA3, 0xC5, 0xE1, 0xAE,
0x20, 0xD7, 0xA1, 0xFF, 0x6D, 0x4C, 0x10, 0x4B,
0x0F, 0xCF, 0xB5, 0x0F, 0x67, 0xA8, 0xA7, 0x8A,
0x33, 0xB7, 0xD8, 0xC2, 0x0E, 0xDB, 0x21, 0xB2,
0xFD, 0xE4, 0xD3, 0x0F, 0xA7, 0x57, 0xFB, 0xD0,
0xDA, 0xBD, 0x36, 0x7C, 0x32, 0x6A, 0x8B, 0x1A,
0x2B, 0x44, 0x98, 0x58, 0xC2, 0x81, 0xFF, 0x5A,
0x4B, 0x61, 0xFE, 0x26, 0x3F, 0xBA, 0x2E, 0xB8,
0xE4, 0xAA, 0x0F, 0x3C, 0x94, 0x1C, 0xCA, 0xD0,
0x01, 0x94, 0x32, 0x14, 0xE5, 0x99, 0x08, 0xD3,
0x19, 0x10, 0x34, 0x6E, 0x16, 0x57, 0x4E, 0x10,
0x5F, 0xFB, 0xF5, 0x68, 0x00, 0x79, 0xA7, 0x8B,
0x57, 0xE4, 0x97, 0x7D, 0x66, 0x66, 0x9F, 0xDA,
0x95, 0x91, 0x96, 0x9E, 0x17,
0x6C, 0x9E, 0xA1, 0x29, 0xC0, 0x72, 0xB5, 0xCD,
0xEF, 0xC9, 0xEA, 0xAE, 0xD0, 0xC8, 0x99, 0x7A,
0xAB, 0xF9, 0x5A, 0xA9, 0x4B, 0x4A, 0x4E, 0x3E,
0xFC, 0x69, 0x27, 0x77, 0xD8, 0x00, 0x04, 0x59,
0x97, 0xC6, 0x34, 0x04, 0xD3, 0x6E, 0x08, 0x40,
0xEE, 0x92, 0xFA, 0x77, 0xE6, 0xFF, 0x5C, 0xBB,
0xDB, 0x4B, 0xA9, 0x3F, 0x27, 0xA7, 0x89, 0x66,
0xE2, 0x5D, 0xAB, 0x64, 0x94, 0x80, 0xBC, 0xC6,
0xDB, 0xAC, 0x15, 0x4B, 0x51, 0x35, 0x20, 0x70,
0xD1, 0xFA, 0x5F, 0xFF, 0xDA, 0x92, 0x74, 0x16,
0x0C, 0x7D, 0x75, 0xDB, 0x10, 0xE7, 0xCE, 0x01,
0x02, 0xE4, 0xC0, 0x3B, 0x1E, 0xBD, 0xF9, 0x61,
0x7F, 0x86, 0x31, 0x3E, 0x9D, 0x38, 0x39, 0x56,
0x2B, 0x6C, 0x0E, 0xFA, 0x30, 0x8A, 0xCF, 0xBA,
0x24, 0x19, 0x97, 0x4C, 0x69, 0x06, 0x20, 0x63,
0x90, 0x50, 0x5E, 0xFA, 0xF8, 0x3C, 0x95, 0x3B,
0x2B, 0x24, 0x91, 0x83, 0x2B, 0x51, 0x78, 0x6A,
0xC8, 0x76, 0xE2, 0xE6, 0xB4, 0xF5, 0x52, 0x4F,
0xD0, 0xF8, 0xAC, 0xF7, 0xC8, 0x41, 0x10, 0x56,
0x08, 0xDD, 0x17, 0x7C, 0x3D, 0xCE, 0x4F, 0x4B,
0x73, 0x16, 0x5D, 0x5F, 0x07, 0xC5, 0xD9, 0x7D,
0x3A, 0xDE, 0x94, 0x83, 0x3D, 0x2B, 0x7D, 0xDC,
0x90, 0xDE, 0x38, 0x3C, 0xA3, 0xFE, 0xC0, 0x2D,
0x03, 0x56, 0x09, 0x38, 0xA7, 0x3A, 0x7A, 0x9F,
0xAF, 0xAE, 0xB6, 0x04, 0x6F, 0xD5, 0x50, 0x24,
0x7B, 0xBB, 0x36, 0xFD, 0x0F, 0xBA, 0x78, 0xD1,
0x70, 0x59, 0xDA, 0x53, 0xFA, 0x60, 0x65, 0xE6,
0xE5, 0xE1, 0x8B, 0xFF, 0xCC, 0xC1, 0xE1, 0xB1,
0xFE, 0xAD, 0x8F, 0xCF, 0x2A, 0x6C, 0x8B, 0x12,
0xCD, 0xDA, 0xAC, 0xDA, 0xDB, 0x9E, 0xAD, 0x24,
0xDF, 0x97, 0x73, 0x83, 0x9F, 0xCC,
0xDE, 0x78, 0x42, 0x8F, 0x68, 0x7F, 0x6B, 0xCC,
0xCC, 0xA1, 0x5D, 0xE3, 0x17, 0x07, 0xE3, 0x60,
0x66, 0xC6, 0x46, 0x96, 0x14, 0xDD, 0x05, 0x6E,
0xC3, 0x02, 0x95, 0x79, 0x69, 0xC2, 0xFC, 0x83,
0x5B, 0x82, 0x8B, 0xE3, 0x69, 0xFC, 0x40, 0x94,
0x63, 0x2C, 0x53, 0xC3, 0xC2, 0x5B, 0x70, 0xCA,
0x1C, 0x1A, 0xC7, 0xC4, 0xFE, 0x24, 0x2A, 0x9F,
0x75, 0x46, 0x88, 0x2F, 0xFD, 0x4E, 0x51, 0x1A,
0x73, 0xF1, 0x72, 0xE5, 0x46, 0x85, 0x21, 0xB8,
0x50, 0xAC, 0x71, 0x9E, 0x01, 0xCF, 0x81, 0x54,
0x7A, 0x4D, 0xFE, 0x6E, 0x7C, 0x6E, 0x0A, 0xBA,
0x2D, 0x18, 0xAC, 0x20, 0xB1, 0x4D, 0x10, 0x90,
0x13, 0xFD, 0x14, 0x69, 0x0B, 0xA0, 0xBC, 0x9C,
0xDB, 0xD1, 0x99, 0x55, 0x77, 0x5F, 0xDB, 0x74,
0x1F, 0x75, 0x15, 0xEF, 0x00, 0xC3, 0xC2, 0xC4,
0xBB, 0xB0, 0xAB, 0x3C, 0x0F, 0xFC, 0x35, 0x0B,
0x6D, 0xA5, 0x9E, 0x70, 0x70, 0x7E, 0xB3, 0xD8,
0x89, 0x9F, 0x6E, 0x95, 0xD4, 0xBC, 0x4B, 0xAA,
0x70, 0x97, 0xD1, 0x1A, 0xD9, 0xD5, 0xCA, 0xFB,
0x11, 0x6A, 0x3E, 0x06, 0xC2, 0x18, 0xD1, 0x7D,
0xE4, 0x61, 0xD4, 0xEF, 0x2E, 0x03, 0x9B, 0xC9,
0xB7, 0x09, 0x56, 0x0F, 0xF9, 0x76, 0xC1, 0x5C,
0x6B, 0x00, 0x1C, 0x11, 0xD2, 0x7C, 0xD4, 0x6F,
0x1D, 0x24, 0x0D, 0x05, 0xDD, 0xAF, 0xA6, 0xE9,
0x16, 0x6B, 0xF9, 0xC9, 0xE3, 0x16, 0x47, 0x78,
0xC7, 0x97, 0xBC, 0x13, 0xD5, 0xDE, 0x2E, 0xC2,
0xCA, 0x99, 0x0D, 0x17, 0x5F, 0x8C, 0x9A, 0x44,
0xD3, 0x9C, 0x66, 0xD1, 0x6C, 0x5A, 0x12, 0xD4,
0xBC, 0x1C, 0x97, 0xA4, 0xE8, 0xB7, 0x86, 0x9F,
0x7D, 0xE4, 0x96, 0x9D, 0xF9, 0xC8, 0x5C, 0xDC,
0xC4, 0xEA, 0xC9, 0x05, 0xAD, 0x15, 0xC2,
0xE5, 0x02, 0x9D, 0x1A, 0xF8, 0xAF, 0xFE, 0x2A,
0x8E, 0x35, 0xF5, 0x6E, 0xF6, 0x94, 0x48, 0x16,
0x82, 0x4F, 0xE5, 0xB2, 0xF7, 0x61, 0x5D, 0x25,
0x79, 0xE2, 0xFC, 0xE6, 0x57, 0x14, 0x19, 0x5C,
0x53, 0xF5, 0x41, 0xCF, 0x33, 0xA1, 0xEA, 0xED,
0x8C, 0x2D, 0x9F, 0xA1, 0x0F, 0xBF, 0xDB, 0x92,
0x1B, 0xE5, 0x62, 0x4E, 0x56, 0x74, 0x81, 0x1F,
0x53, 0x10, 0x69, 0x44, 0xE6, 0x82, 0x86, 0xB1,
0x18, 0x5F, 0x70, 0xC1, 0x6D, 0x00, 0xB0, 0x5B,
0x04, 0x17, 0x0E, 0xDB, 0xAA, 0xB7, 0x62, 0x48,
0x2F, 0x80, 0x2F, 0x02, 0x01, 0x9F, 0x33, 0x36,
0x3E, 0xF3, 0x96, 0x4D, 0x23, 0x92, 0xEC, 0xB0,
0x59, 0x03, 0xB6, 0xCE, 0x26, 0xE4, 0x36, 0xE6,
0xBD, 0x6A, 0xE0, 0xEF, 0x51, 0xED, 0xE0, 0xAB,
0xA2, 0x45, 0x9C, 0x2F, 0xDD, 0x46, 0xB4, 0x9D,
0x89, 0xD1, 0xBB, 0x91, 0x29, 0xFC, 0xCA, 0x27,
0xA7, 0xE0, 0x22, 0x68, 0x1F, 0xDD, 0xCA, 0x49,
0x0B, 0xC9, 0x4F, 0xBC, 0xDA, 0xF1, 0xAA, 0x5D,
0x3A, 0x8E, 0xC2, 0x50, 0xAA, 0xE7, 0x7C, 0x30,
0x8E, 0x4B, 0x92, 0x22, 0xA7, 0x55, 0x92, 0xBB,
0x77, 0xD6, 0xDF, 0xFC, 0x3E, 0x43, 0x8B, 0xF1,
0x43, 0x6F, 0x9A, 0x93, 0x02, 0xBD, 0x16, 0xA2,
0xE7, 0x84, 0xDB, 0xF3, 0x5C, 0xF6, 0x49, 0xF6,
0x8A, 0xB4, 0x06, 0x2F, 0xF6, 0x9B, 0xE7, 0xD4,
0x3C, 0x89, 0x82, 0x3D, 0x59, 0x52, 0x6E, 0x9F,
0x55, 0xC6, 0x2E, 0x14, 0x9B, 0x97, 0xBD, 0x4C,
0xCD, 0x3A, 0xA3, 0xAC, 0xA1, 0x9B, 0x43, 0x92,
0x79, 0xD5, 0x08, 0x7A, 0x08, 0xA7, 0x08, 0x7E,
0x47, 0xC5, 0xBB, 0x14, 0x62, 0x8F, 0x31, 0x14,
0x1A, 0x3D, 0x11, 0x5D, 0x19, 0xBC, 0x92, 0xC9,
0x8B, 0xF7, 0x9D, 0x77, 0x55, 0x16, 0xE4, 0xD7,
0x88, 0x47, 0xFB, 0x24, 0xEE, 0x57, 0x38, 0x6E,
0x77, 0x56, 0xCF, 0xB4, 0x01, 0xE4, 0x0F, 0x7B,
0x7D, 0x05, 0xB1, 0xF1, 0x1A, 0x23, 0x97, 0xC0,
0x27, 0x0B, 0x91, 0xD9, 0xFE, 0x6E, 0x44, 0x1C,
0x50, 0x70, 0x90, 0xAD, 0xEB, 0x85, 0x7B, 0xC4,
0xA0, 0xAA, 0xCB, 0x90, 0xD5, 0x95, 0x5F, 0xB5,
0xEA, 0x85, 0x7C, 0x0D, 0xC4, 0x80, 0x13, 0xBD,
0xD6, 0xAB, 0x95, 0xAE, 0x57, 0xF8, 0x33, 0xAD,
0x96, 0x86, 0xAD, 0xAC, 0x41, 0x73, 0x7C, 0x71,
0x12, 0x89, 0xF3, 0x72, 0x50, 0x35, 0xD2, 0x49,
0x33, 0xD3, 0x79, 0xBC, 0xAD, 0x4B, 0xE4, 0xD3,
0x4E, 0x51, 0x1D, 0xD8, 0x8F, 0x7C, 0x8B, 0x81,
0xDC, 0xCE, 0x94, 0x6C, 0xCB, 0x69, 0x8D, 0x83,
0xC1, 0x4C, 0xF4, 0x53, 0x62, 0x8A, 0xBF, 0x89,
0xB5, 0x43, 0x8A, 0x87, 0x59, 0xDB, 0x9D, 0x13,
0xBE, 0xF8, 0x92, 0x76, 0x29, 0x7D, 0xBC, 0xF7,
0xCE, 0x1B, 0x00, 0xD0, 0xD1, 0x36, 0x56, 0x7E,
0x9D, 0x53, 0xFE, 0x19, 0x70, 0x74, 0xFB, 0xF6,
0xC4, 0xD0, 0xC2, 0x2D, 0x5B, 0x12, 0xD1, 0x3C,
0x19, 0x27, 0x29, 0xA8, 0x37, 0x61, 0x8A, 0x42,
0x97, 0x8A, 0x56, 0x39, 0x98, 0x0F, 0x83, 0xF5,
0x1F, 0x2A, 0x1C, 0xE6, 0xB7, 0xF3, 0xC5, 0x93,
0x0D, 0x31, 0xE0, 0xCE, 0xFC, 0x01, 0x78, 0xF8,
0x8D, 0x3B, 0x8A, 0x9F, 0x23, 0x9F, 0x26, 0x9F,
0x47, 0x95, 0x5C, 0x34, 0x0D, 0xD6, 0xE4, 0xE8,
0xB6, 0x58, 0x98, 0x19, 0xA2, 0x6F, 0x58, 0x28,
0x00, 0x60, 0xE1, 0x62, 0xC1, 0x68, 0xDF, 0x07,
0x52, 0xBF, 0x28, 0xB7, 0xC9, 0xA6, 0xCE, 0x1A,
0x61, 0x3A, 0xA7, 0x3D, 0x15, 0x67, 0xA0, 0xA3,
0x2A, 0x7B, 0x39, 0x38, 0x2C, 0xA5, 0xBB, 0xCE,
0x5E, 0xC6, 0xB3, 0x09, 0xFB, 0x61, 0xF4, 0x02,
0x8A,
0xD5, 0xAC, 0xFB, 0x4F, 0x0A, 0xD0, 0xCD, 0xB4,
0x95, 0x00, 0x85, 0x6F, 0xE7, 0x75, 0x3A, 0xDE,
0x03, 0xB8, 0xA9, 0x33, 0xA5, 0xE1, 0x96, 0x0A,
0xFF, 0x26, 0xBE, 0x39, 0x91, 0xD7, 0x41, 0xBA,
0xA5, 0x14, 0xC3, 0xFF, 0x8D, 0x40, 0x20, 0xE1,
0x4A, 0xBE, 0xE7, 0x1C, 0x42, 0x8E, 0x6A, 0xCB,
0x82, 0x36, 0xC7, 0xB5, 0x2C, 0xE1, 0xDF, 0x85,
0xF9, 0x06, 0xFA, 0x5C, 0x16, 0x14, 0x64, 0x7C,
0x80, 0xA8, 0xC5, 0xCB, 0xE8, 0xFD, 0xEF, 0x2F,
0xDC, 0xD6, 0xBA, 0x6A, 0xF7, 0xDA, 0x35, 0x6D,
0xBE, 0x24, 0xCD, 0xD1, 0x16, 0xC0, 0xF5, 0x4B,
0x04, 0x66, 0xEF, 0x49, 0x01, 0x96, 0xF6, 0x91,
0x2B, 0xA3, 0x73, 0xDA, 0x83, 0x8E, 0xA0, 0x59,
0xFE, 0x62, 0x5F, 0xB8, 0xCD, 0xDD, 0x5A, 0xFC,
0x14, 0xBA, 0x72, 0xE0, 0x87, 0xB4, 0x81, 0x2A,
0xB0, 0x65, 0x2F, 0x52, 0x22, 0x6F, 0xF0, 0x2C,
0xF5, 0xE9, 0x8D, 0x53, 0x3E, 0xE3, 0x18, 0x50,
0x8F, 0x20, 0x1E, 0xA4, 0x6C, 0x8F, 0x8E, 0xA8,
0xA3, 0xC4, 0x33, 0xF6, 0x29, 0x52, 0x16, 0x34,
0x6F, 0x75, 0x14, 0xE2, 0x4B, 0xB6, 0xE9, 0x30,
0x38, 0x40, 0x04, 0xD2, 0x87, 0xB3, 0x5A, 0xC9,
0xC8, 0x58, 0x93, 0x19, 0x3E, 0xC7, 0xC2, 0xB8,
0x4F, 0x89, 0xCB, 0x6C, 0x2B, 0x8D, 0xA6, 0x0B,
0xFF, 0xAE, 0xF9, 0xE5, 0xAC, 0x95, 0xC6, 0xA6,
0x99, 0x8C, 0x6F, 0xBC, 0x06, 0x98, 0x9B, 0xDE,
0xE7, 0x1D, 0x82, 0x63, 0xC3, 0x94, 0x41, 0x83,
0xE1, 0x83, 0x7F, 0xD2, 0xA5, 0x30, 0xC0, 0x23,
0x65, 0x18, 0xD6, 0xE8, 0x1E, 0x7A, 0x17, 0x50,
0xB5, 0xF9, 0x88, 0x8C, 0x66, 0x7D, 0x75, 0xF1,
0x2F, 0x17, 0xD2, 0x09, 0x04, 0x86, 0x20, 0xF4,
0xA2, 0x5B, 0x21, 0xC2, 0x3C, 0x33, 0xA2, 0xC3,
0xAD, 0xF7,
0x5F, 0x35, 0xFE, 0xB3, 0x32, 0x61, 0x6B, 0x7F,
0xFB, 0x75, 0x52, 0x1A, 0x03, 0x64, 0x8B, 0x68,
0x33, 0x11, 0x86, 0x7F, 0xE8, 0xDB, 0x9D, 0x5D,
0x12, 0xC4, 0xB3, 0x4C, 0x91, 0x87, 0xBA, 0xE3,
0x76, 0x3D, 0x0C, 0x93, 0x98, 0xCB, 0xE4, 0x46,
0xE8, 0xB8, 0x72, 0x43, 0xC6, 0x2B, 0xAE, 0xD2,
0xCA, 0x16, 0xF1, 0x27, 0xA4, 0x5A, 0x40, 0xE8,
0xB3, 0x63, 0x5D, 0xBF, 0xF8, 0x5E, 0x39, 0xBA,
0xB5, 0x6B, 0x25, 0x0A, 0xBC, 0x34, 0x61, 0xC9,
0x14, 0x69, 0x6A, 0x63, 0x09, 0xFC, 0xCD, 0x2C,
0x21, 0xAC, 0x81, 0x14, 0x8C, 0xBA, 0x6B, 0xDF,
0xFD, 0x8E, 0x10, 0x0D, 0xF1, 0x76, 0xC8, 0x8F,
0x73, 0xF3, 0xF3, 0x52, 0x87, 0x92, 0xA1, 0xCE,
0x16, 0x2D, 0x74, 0xED, 0x2A, 0x15, 0x8D, 0x6D,
0x29, 0xCF, 0xE8, 0xAF, 0xDE, 0xA7, 0xE3, 0xCC,
0x20, 0x8F, 0xC3, 0x87, 0xD4, 0x2E, 0x76, 0xAA,
0x9C, 0x75, 0xD0, 0xBB, 0x2B, 0xF9, 0xB0, 0x27,
0x3D, 0xB7, 0xEF, 0xC6, 0x9B, 0x64, 0xA1, 0x98,
0x80, 0x5F, 0xB2, 0x16, 0x75, 0xE7, 0xB0, 0x14,
0xE3, 0xBB, 0xFC, 0xCF, 0xA3, 0xC0, 0xB9, 0xFB,
0xAA, 0x92, 0x1F, 0x9D, 0x4D, 0x44, 0xC3, 0xF2,
0x76, 0x5B, 0x75, 0x38, 0xB9, 0x49, 0x8D, 0x80,
0xBB, 0xC8, 0xAD, 0xCC, 0x5C, 0xE5, 0xD7, 0x88,
0xCC, 0x28, 0x66, 0xF9, 0xE1, 0x7C, 0x51, 0xA4,
0x35, 0x39, 0x8B, 0xA0, 0xE3, 0x45, 0x20, 0xF1,
0x74, 0x27, 0xCD, 0xA4, 0x0C, 0xF6, 0xE4, 0xFB,
0xCA, 0x22, 0x67, 0x10, 0x32, 0xAA, 0xC8, 0x7C,
0xDE, 0x74, 0xF5, 0x19, 0x8C, 0x6D, 0xD4, 0xDA,
0x2C, 0x78, 0xF5, 0x58, 0x39, 0x24, 0xA5, 0xA2,
0xEE, 0x02, 0x0E, 0x13, 0x4C, 0x91, 0xAE, 0x22,
0x1B, 0x0D, 0x79, 0x55, 0x78, 0x26, 0x64, 0x13,
0x89, 0xB8, 0x31,
0xF5, 0x7C, 0xC8, 0x18, 0xF0, 0x80, 0xBE, 0x09,
0xE9, 0x67, 0x63, 0x48, 0x97, 0x91, 0x69, 0xD2,
0x47, 0x14, 0x3C, 0x1B, 0xCA, 0xBC, 0x76, 0xBC,
0xD8, 0x97, 0xA7, 0xEA, 0xDB, 0x6E, 0x77, 0x96,
0xEE, 0xAB, 0x37, 0x0F, 0x5E, 0xA7, 0xCE, 0xC6,
0xFF, 0x47, 0xD0, 0xDB, 0x05, 0x91, 0x16, 0xF6,
0x44, 0x68, 0x5B, 0x5C, 0x7C, 0x3F, 0xE1, 0x02,
0x3C, 0xA5, 0x57, 0x38, 0x78, 0x51, 0x6E, 0x78,
0x65, 0x7A, 0x8B, 0x4D, 0x85, 0x41, 0x1F, 0x86,
0x2C, 0xEA, 0xEC, 0x8E, 0x03, 0x96, 0x35, 0xE2,
0x6D, 0xE2, 0xED, 0x86, 0x28, 0xA0, 0x1D, 0x47,
0x99, 0x14, 0x1C, 0x8D, 0x88, 0x56, 0x34, 0x9F,
0xF9, 0x22, 0xDD, 0x80, 0x30, 0x20, 0x45, 0xDD,
0x75, 0x0D, 0x2E, 0x07, 0x73, 0xC4, 0x68, 0x97,
0x2B, 0x04, 0xA4, 0xAE, 0x87, 0xB6, 0x71, 0x76,
0x37, 0x7C, 0x06, 0x5C, 0x24, 0xE3, 0xDC, 0x2E,
0xEB, 0x40, 0x87, 0x36, 0xBB, 0x4E, 0xBC, 0xA9,
0xB9, 0xD1, 0xEB, 0x23, 0x51, 0x7C, 0x48, 0xEA,
0x39, 0x8E, 0xE0, 0xFA, 0x04, 0x60, 0xED, 0x25,
0x64, 0xB5, 0x35, 0x2D, 0xAA, 0x51, 0xE2, 0x52,
0x02, 0x21, 0x52, 0x2E, 0x00, 0x94, 0x09, 0x4C,
0xF6, 0x8A, 0xDC, 0xF3, 0xA7, 0xFC, 0xB4, 0xAB,
0x41, 0xF0, 0xEE, 0x21, 0x0A, 0x3D, 0xC3, 0xCD,
0x85, 0x9E, 0xDB, 0xF4, 0xDB, 0x1F, 0xCC, 0x76,
0xCF, 0xE3, 0x00, 0x92, 0xF1, 0xB8, 0xE4, 0x7C,
0xF7, 0x7C, 0x58, 0xDE, 0x33, 0x14, 0x29, 0x14,
0x3B, 0x09, 0x96, 0xD8, 0xC1, 0xA0, 0x13, 0xFD,
0x46, 0x41, 0xE4, 0xF2, 0xA3, 0xC7, 0x82, 0x09,
0x65, 0xC3, 0x31, 0xFD, 0xD7, 0x2B, 0x2C, 0xD3,
0xA7, 0xF6, 0x8D, 0xBD, 0x28, 0x71, 0x9A, 0x97,
0x2E, 0x4B, 0xE4, 0x8C, 0x41, 0xCA, 0x06, 0xA0,
0x2E, 0x98, 0x93, 0x5C,
0x4B, 0xF9, 0x62, 0x96, 0xBA, 0xF1, 0x1F, 0x4E,
0x1E, 0xA5, 0x83, 0xA0, 0x0E, 0x43, 0x65, 0xEA,
0x5F, 0x04, 0xD3, 0x95, 0x5C, 0x2F, 0x8E, 0xCB,
0xE9, 0xDC, 0xFD, 0xF1, 0xA4, 0x01, 0x4C, 0x69,
0x71, 0xF2, 0xEA, 0xF2, 0x35, 0x09, 0x55, 0x79,
0xFA, 0x14, 0x86, 0xB0, 0x1D, 0x3B, 0xBF, 0xBB,
0x1A, 0x38, 0x2B, 0x52, 0x36, 0x59, 0x1C, 0x9C,
0x35, 0x5A, 0xF8, 0x19, 0xE3, 0x2B, 0xA1, 0xF4,
0xAB, 0xA9, 0x31, 0x6E, 0x96, 0xBF, 0x74, 0x1E,
0x17, 0x27, 0x98, 0x6C, 0x40, 0x1C, 0xDE, 0x52,
0x69, 0x67, 0x16, 0x42, 0x0F, 0xAA, 0x0E, 0xB1,
0x63, 0xD0, 0x39, 0xD2, 0x69, 0x54, 0x72, 0x93,
0x8F, 0xBD, 0x48, 0x6B, 0x46, 0x54, 0xB5, 0x6A,
0x36, 0xEC, 0xE9, 0x12, 0xBE, 0xF6, 0x2E, 0xEB,
0xD2, 0xC9, 0x78, 0xE8, 0x8C, 0xEE, 0x8C, 0xCA,
0x8B, 0x5F, 0x11, 0xBD, 0xC1, 0x36, 0x36, 0x5F,
0x16, 0x82, 0x7D, 0xC7, 0xC9, 0x65, 0x57, 0x62,
0x9A, 0x4C, 0xE8, 0xB4, 0xA8, 0x43, 0x04, 0x81,
0x75, 0x00, 0x95, 0xAA, 0xE1, 0xA8, 0x2A, 0xA6,
0x25, 0xF8, 0x23, 0x8E, 0x61, 0x0A, 0x0F, 0x8B,
0x5A, 0xA1, 0xDA, 0xA3, 0x10, 0xAF, 0x4D, 0xBC,
0xB9, 0xE2, 0x52, 0x5E, 0x68, 0x9D, 0x45, 0x86,
0x60, 0x5F, 0x41, 0x3E, 0x3F, 0xD0, 0xF4, 0x05,
0x4F, 0x46, 0xD9, 0x51, 0xD7, 0x4E, 0x53, 0x3F,
0x0B, 0x1A, 0xCC, 0x8A, 0xE1, 0x22, 0x28, 0x7E,
0x98, 0x77, 0xBE, 0x14, 0x8A, 0x37, 0x1E, 0xD8,
0xA6, 0x22, 0x24, 0x0C, 0x0C, 0xA3, 0x59, 0xF9,
0x00, 0x16, 0x9D, 0xF6, 0xF0, 0x19, 0xD6, 0xC1,
0x1E, 0x72, 0x33, 0xB7, 0x03, 0xA1, 0x2C, 0x93,
0x87, 0x2B, 0xC0, 0x9A, 0x6B, 0xD0, 0x2F, 0xF3,
0x28, 0x28, 0x3A, 0x8C, 0x23, 0x44, 0x20, 0x06,
0x57, 0x14, 0x0A, 0x0F, 0x7D,
0xD0, 0x62, 0xF2, 0x9F, 0xAC, 0x51, 0xC2, 0x0D,
0xC6, 0xAE, 0xD0, 0x94, 0xAB, 0xC7, 0x0C, 0x1C,
0xCD, 0xA4, 0x61, 0x28, 0x95, 0xE5, 0xC2, 0x24,
0x3A, 0x86, 0xDB, 0x13, 0x65, 0xE4, 0xBD, 0xEF,
0x90, 0x77, 0xDE, 0x7E, 0xD1, 0x11, 0x6E, 0x8C,
0xF7, 0x0B, 0xA5, 0x2E, 0x00, 0xE3, 0x53, 0x30,
0x7E, 0xB3, 0x98, 0x86, 0x52, 0x98, 0x4D, 0xEE,
0xAC, 0xD5, 0x53, 0xD6, 0x44, 0x58, 0x1D, 0xA1,
0x9E, 0xCA, 0xC5, 0x86, 0xB9, 0x98, 0xEF, 0x50,
0x07, 0x56, 0x48, 0xCB, 0xB0, 0x22, 0x47, 0xE5,
0xFE, 0x88, 0xA0, 0xD3, 0xC8, 0xB0, 0xA1, 0xC4,
0xE0, 0x4C, 0xA7, 0x69, 0x4E, 0x6E, 0xDC, 0x01,
0x37, 0x69, 0x2B, 0xEB, 0x94, 0x02, 0x08, 0x9F,
0x1B, 0xB5, 0xAE, 0xA5, 0x6F, 0x87, 0x0B, 0xD1,
0x5A, 0x64, 0x27, 0x69, 0xE6, 0x4C, 0x8A, 0x5D,
0x11, 0x42, 0x58, 0x08, 0x13, 0xBC, 0x96, 0xF5,
0x3E, 0x34, 0x42, 0xC5, 0xFF, 0xBE, 0x0A, 0x75,
0x91, 0x85, 0x12, 0x24, 0xD1, 0x71, 0x8F, 0xAB,
0x05, 0x25, 0xDA, 0x4E, 0x2B, 0x6C, 0x34, 0x8B,
0xF0, 0x80, 0x45, 0x33, 0xA7, 0xEE, 0x5B, 0x4B,
0xA5, 0x60, 0xB8, 0x98, 0x0C, 0x69, 0x0F, 0x62,
0x14, 0xE3, 0x01, 0x16, 0x4C, 0x80, 0x66, 0xE2,
0xBE, 0x7D, 0x4E, 0xA8, 0xCC, 0xE5, 0xA1, 0xE2,
0xA1, 0x35, 0x4B, 0x1C, 0x3F, 0x3A, 0xB2, 0xC1,
0xE3, 0x64, 0x68, 0xB1, 0x7C, 0x38, 0xA9, 0xA0,
0x09, 0x66, 0xEB, 0x97, 0xEA, 0x2F, 0x22, 0x8C,
0x55, 0x25, 0x7E, 0xC5, 0x9D, 0x5C, 0xEE, 0x99,
0x41, 0x48, 0xC0, 0xCA, 0x20, 0xF8, 0x38, 0x65,
0xF1, 0x74, 0x45, 0x28, 0xC3, 0xD2, 0x47, 0xBF,
0xC3, 0xD1, 0xDC, 0x07, 0x68, 0x8B, 0x70, 0xC0,
0x60, 0xC8, 0x5E, 0x2A, 0x81, 0x0A, 0x0B, 0x40,
0x14, 0xC9, 0xF1, 0x48, 0xDC, 0xFF,
0x7F, 0x4E, 0x09, 0x33, 0x0D, 0xEF, 0x06, 0x2D,
0xA3, 0x79, 0x84, 0xB5, 0x65, 0x9E, 0x8D, 0x08,
0x6A, 0xA9, 0xC9, 0x9B, 0x34, 0xFA, 0x3D, 0x38,
0x0A, 0x6A, 0xDE, 0xDE, 0xDF, 0x45, 0x7C, 0xAC,
0xDC, 0x94, 0xC0, 0xD8, 0x1B, 0xA6, 0xAB, 0x18,
0x3A, 0x71, 0xEF, 0xD8, 0x43, 0xE6, 0x29, 0x39,
0x62, 0xF9, 0x4A, 0xAC, 0x02, 0xFB, 0x5E, 0x28,
0xE9, 0x66, 0xF3, 0x1C, 0x86, 0xC5, 0x0B, 0x87,
0xFF, 0xE1, 0x76, 0x0A, 0x74, 0x36, 0x77, 0x6B,
0x8F, 0x88, 0xD2, 0xF9, 0x5C, 0xFB, 0x5E, 0x64,
0xBF, 0xCD, 0x20, 0x73, 0x07, 0x1B, 0xF6, 0x95,
0x1F, 0xCB, 0xB5, 0x9F, 0x8E, 0xC2, 0xE2, 0x71,
0x13, 0xD1, 0x4E, 0xFC, 0x3A, 0x75, 0xC6, 0xDD,
0x3C, 0x55, 0xE4, 0xE5, 0x65, 0x5A, 0xD5, 0x70,
0xDF, 0x88, 0x66, 0x9F, 0x02, 0x95, 0x54, 0xFA,
0xBF, 0x2C, 0x20, 0x67, 0x29, 0x89, 0x6B, 0xC2,
0x83, 0x4C, 0xCD, 0xAD, 0x58, 0xF0, 0x8A, 0x1E,
0x30, 0xF1, 0xC6, 0x54, 0x25, 0x5B, 0x89, 0x67,
0x26, 0x11, 0x03, 0x69, 0xEF, 0xAB, 0x56, 0xB8,
0x46, 0x2A, 0xF7, 0x4B, 0xDF, 0x4E, 0xE8, 0x62,
0xE0, 0x27, 0x00, 0xA9, 0xE3, 0x47, 0x42, 0x41,
0xA3, 0x5B, 0xEB, 0x20, 0xEE, 0x3E, 0x28, 0x50,
0x00, 0x11, 0x18, 0x32, 0xC5, 0x2D, 0xE5, 0xC3,
0x96, 0x73, 0xEF, 0xAA, 0xF8, 0xAF, 0xF4, 0x89,
0xB6, 0x0E, 0xD9, 0xB1, 0xF0, 0xE4, 0x06, 0x69,
0x5C, 0x7F, 0x20, 0xE2, 0xD9, 0xDE, 0x2E, 0x5D,
0x8D, 0x73, 0x56, 0xD7, 0xE7, 0xE8, 0xAB, 0x33,
0xBB, 0x2D, 0x54, 0x0D, 0x96, 0xC1, 0x4B, 0xF9,
0x39, 0x31, 0x6E, 0x95, 0x67, 0xD8, 0x37, 0x8B,
0xCE, 0xDC, 0x4D, 0x67, 0x9E, 0x55, 0x17, 0x9C,
0x6F, 0x4F, 0xF9, 0x23, 0x70, 0x84, 0xA5, 0xB8,
0xA2, 0xC2, 0xE7, 0x6C, 0xBB, 0xF9, 0x45,
0x54, 0x2A, 0xE8, 0xD1, 0xC2, 0xCA, 0x67, 0xDB,
0xF1, 0xCD, 0x7F, 0x0A, 0xD1, 0x61, 0x3A, 0x42,
0x29, 0xAD, 0x8F, 0x3E, 0x66, 0x81, 0x9F, 0xDD,
0x15, 0x26, 0x6A, 0xE4, 0x69, 0x4B, 0x7C, 0xAB,
0xE2, 0x00, 0x36, 0xBF, 0x77, 0x53, 0x40, 0xF8,
0xB9, 0xBE, 0x5F, 0x17, 0x31, 0xEF, 0xEF, 0x83,
0xB8, 0x7E, 0x46, 0xDB, 0x99, 0x2F, 0x9A, 0x7F,
0x41, 0x38, 0xA1, 0x0F, 0x0A, 0xDA, 0x49, 0x45,
0x33, 0xA7, 0x07, 0xA5, 0xB5, 0xAF, 0x06, 0x2B,
0xA8, 0x07, 0xC4, 0x11, 0x71, 0x19, 0x36, 0x57,
0x0E, 0x09, 0xB9, 0x84, 0xB9, 0x6C, 0x8F, 0x5E,
0x24, 0xA2, 0x29, 0x36, 0x9A, 0x79, 0x0F, 0x20,
0xC4, 0x6C, 0xD8, 0xB8, 0xD6, 0x24, 0x40, 0x86,
0xA8, 0x41, 0x17, 0xA4, 0x84, 0x3C, 0x1B, 0x53,
0xA8, 0xFF, 0x52, 0xA1, 0x53, 0x35, 0xC8, 0xDB,
0x85, 0x79, 0xB8, 0x82, 0x4A, 0x52, 0x33, 0x68,
0xFC, 0xA0, 0x4C, 0x84, 0x31, 0x86, 0x4C, 0x1A,
0xD5, 0x7E, 0xE5, 0xD4, 0x3F, 0xDD, 0x97, 0x60,
0xD1, 0xA6, 0x1F, 0xA2, 0x2C, 0x64, 0xF0, 0xF2,
0xA9, 0x07, 0x02, 0x5C, 0x4F, 0xF3, 0x47, 0xA6,
0xB0, 0xA4, 0xA0, 0xE5, 0x12, 0xCA, 0x28, 0x59,
0x09, 0x66, 0x93, 0x41, 0x71, 0x1E, 0x74, 0x71,
0xCB, 0xC0, 0x01, 0xEA, 0x84, 0xAC, 0xAF, 0xA9,
0x62, 0xE3, 0xDD, 0xBD, 0x2D, 0x9C, 0x46, 0xE1,
0xAB, 0x9F, 0xB0, 0xBD, 0xE3, 0xE1, 0x7C, 0xB7,
0x55, 0xBF, 0x8E, 0xB5, 0x45, 0x88, 0xEC, 0xFD,
0xFE, 0x52, 0xFC, 0x51, 0xE7, 0x5B, 0x62, 0x7E,
0x39, 0x66, 0xAD, 0x6F, 0xE2, 0xEA, 0x99, 0xDB,
0xCB, 0x99, 0x7C, 0x14, 0x79, 0x19, 0xDF, 0x00,
0x71, 0xE1, 0x26, 0xC8, 0xFA, 0x22, 0x6E, 0xFD,
0xB7, 0x35, 0x57, 0xD5, 0xFC, 0x72, 0x4E, 0x84,
0x26, 0x69, 0x50, 0xD1, 0x5F, 0xA7, 0xE1, 0x93,
0x8D, 0x34, 0x0A, 0xCF, 0x32, 0x9C, 0xA6, 0x72,
0x28, 0x5D, 0xE3, 0xA3, 0x04, 0xAB, 0x6D, 0x3B,
0x9A, 0xC1, 0x30, 0x4F, 0x18, 0x37, 0xA3, 0x20,
0x5B, 0xE7, 0xC8, 0x5A, 0x0E, 0x63, 0x49, 0xD4,
0x90, 0x6D, 0xF0, 0xA3, 0xA3, 0xF9, 0xDF, 0xC0,
0x73, 0xE6, 0xBB, 0xE2, 0xC6, 0xBB, 0x02, 0x96,
0x69, 0x86, 0x65, 0xF1, 0x74, 0xB7, 0x22, 0xB4,
0x2C, 0x5B, 0xD4, 0x6D, 0x9C, 0xB8, 0xBB, 0x71,
0xB0, 0x71, 0x7F, 0xF8, 0xCE, 0xCE, 0xD3, 0x60,
0xC7, 0x40, 0x33, 0xCF, 0x7B, 0x27, 0xF9, 0x60,
0x82, 0x84, 0x51, 0xF9, 0x09, 0xE3, 0x61, 0xC0,
0x03, 0xF9, 0xDB, 0x84, 0xC7, 0xD5, 0xDE, 0xB8,
0x2A, 0x8F, 0x63, 0x47, 0x4B, 0x85, 0x66, 0xC1,
0xE8, 0xDF, 0x52, 0x2F, 0xBC, 0xD3, 0x9D, 0x7B,
0x32, 0xA6, 0x11, 0x5B, 0x1F, 0xB8, 0xC5, 0x94,
0xA5, 0x6C, 0xB3, 0x68, 0xA1, 0xB8, 0x43, 0xDA,
0x01, 0x79, 0xC8, 0xDF, 0xC1, 0x5F, 0x2E, 0xE7,
0x61, 0xFC, 0x87, 0x90, 0x64, 0x99, 0x6C, 0x13,
0x0F, 0xF9, 0x6E, 0xEE, 0x3E, 0xB3, 0x87, 0x00,
0x58, 0x98, 0x1C, 0x2C, 0xEA, 0x4A, 0x46, 0x31,
0xF3, 0x97, 0x65, 0xC1, 0x43, 0x57, 0x13, 0xC7,
0xB7, 0xFE, 0xC0, 0x59, 0xE9, 0x8E, 0x7B, 0xBF,
0x17, 0x87, 0x46, 0x21, 0xBD, 0x77, 0x30, 0xB5,
0xC1, 0xEF, 0xEE, 0x32, 0xC2, 0xC1, 0x4D, 0x88,
0xB0, 0xA2, 0xEB, 0xE1, 0xDF, 0xE1, 0x40, 0xA9,
0x17, 0x8A, 0x05, 0xDC, 0x29, 0x99, 0x4C, 0xC1,
0x29, 0xC7, 0x05, 0x42, 0x7A, 0x70, 0x1C, 0x9A,
0xB4, 0x9B, 0x7D, 0xFA, 0x79, 0x58, 0x90, 0x8F,
0x13, 0x39, 0xFC, 0x78, 0xF8, 0x4C, 0x54, 0x25,
0x01, 0x46, 0x8A, 0x01, 0x45, 0xFF, 0x44, 0x43,
0x27, 0x03, 0xA4, 0xD7, 0xD2, 0xAA, 0xC1, 0xC8,
0x39, 0x19, 0x16, 0x91, 0x65, 0xAF, 0xAE, 0x73,
0x5F,
0xFC, 0xA8, 0xE4, 0x40, 0x01, 0x91, 0xBB, 0x33,
0xF0, 0x85, 0x3F, 0xD1, 0xE9, 0x68, 0x59, 0xC9,
0x6C, 0x27, 0xBB, 0xE8, 0xCA, 0x1F, 0x16, 0x03,
0xB8, 0xF0, 0xC9, 0x12, 0xA4, 0xD9, 0xBC, 0x9F,
0x71, 0x9B, 0xDE, 0xF5, 0x92, 0x6C, 0xB8, 0xA0,
0x33, 0x7B, 0xBD, 0x62, 0x0B, 0xDA, 0x5A, 0x1C,
0x2C, 0x8D, 0x13, 0xDC, 0xF2, 0xFC, 0xB2, 0xC0,
0x19, 0xE0, 0x70, 0x57, 0x7B, 0x42, 0x5C, 0x6E,
0x68, 0xD6, 0x39, 0x04, 0x4D, 0x5A, 0xDC, 0xB1,
0x55, 0x74, 0x19, 0x06, 0xC3, 0xD3, 0x04, 0x75,
0xB6, 0x1C, 0x4E, 0x3F, 0x08, 0x82, 0x96, 0xD2,
0x37, 0x9E, 0xD3, 0x69, 0xCF, 0x23, 0xEF, 0x3A,
0xA4, 0x70, 0x10, 0xAE, 0x57, 0xC7, 0xD7, 0x17,
0x31, 0xCF, 0x2C, 0x95, 0xD0, 0x57, 0xB3, 0xC3,
0xC0, 0xC4, 0xE8, 0x92, 0x74, 0x21, 0x07, 0x69,
0xB6, 0xAA, 0xBD, 0x7E, 0x83, 0x2C, 0xC6, 0xBC,
0x36, 0x3B, 0xDD, 0x3B, 0x7F, 0xC3, 0xE9, 0xA5,
0xDD, 0xB1, 0x19, 0x23, 0x8D, 0x6F, 0x5A, 0x6E,
0xEE, 0x6B, 0x88, 0x50, 0x8D, 0x36, 0x06, 0x40,
0x76, 0x44, 0x5D, 0x89, 0x41, 0x79, 0x24, 0x31,
0x7A, 0x23, 0x36, 0x5C, 0xE9, 0xBD, 0x09, 0x53,
0x6E, 0x7E, 0xC1, 0xAF, 0x9D, 0x05, 0x2C, 0x1A,
0x15, 0x32, 0xE1, 0x20, 0xEF, 0x43, 0x8B, 0x27,
0x5A, 0x7F, 0x55, 0x3D, 0xA2, 0x83, 0x43, 0xAF,
0x29, 0xC7, 0xF7, 0xC8, 0x4D, 0x6F, 0x1C, 0xBF,
0xB2, 0x66, 0x48, 0x5C, 0xFD, 0xA3, 0xD5, 0x71,
0xDD, 0xC0, 0x5E, 0x9F, 0x99, 0x72, 0x78, 0x40,
0x61, 0x4D, 0x7E, 0x33, 0xD7, 0x06, 0x5F, 0x41,
0x85, 0xAA, 0x6A, 0x55, 0x27, 0x21, 0x80, 0xC4,
0x6B, 0xD8, 0xE8, 0x69, 0x91, 0x83, 0xF3, 0x62,
0x98, 0xB4, 0xF3, 0xCF, 0xB0, 0x00, 0x8E, 0x71,
0x50, 0xF6, 0x20, 0xEF, 0x69, 0x88, 0xAF, 0x5C,
0xF7, 0x85,
0x26, 0x79, 0x83, 0x1D, 0x83, 0x57, 0x06, 0xCD,
0x07, 0xCB, 0x21, 0x77, 0x14, 0x34, 0x34, 0xD4,
0x07, 0xBB, 0xFC, 0xBE, 0x8C, 0xDB, 0x21, 0x1A,
0xE6, 0x15, 0x8A, 0xFF, 0x4A, 0x45, 0x0B, 0x45,
0x2D, 0xBF, 0x5D, 0xA3, 0x2B, 0x08, 0x84, 0xC5,
0x3E, 0x68, 0xAF, 0x6E, 0x99, 0x50, 0x49, 0x49,
0x7A, 0x52, 0x1D, 0x02, 0xF8, 0x9A, 0x8C, 0xDF,
0xEA, 0x73, 0xBA, 0x47, 0xD3, 0x60, 0x8A, 0x84,
0x3A, 0xF6, 0x92, 0xAE, 0x00, 0xD3, 0x77, 0x07,
0x8F, 0xF2, 0xD5, 0xF8, 0x6C, 0xDB, 0x7D, 0x6F,
0x53, 0x04, 0xB2, 0x0E, 0x81, 0x32, 0x55, 0xBC,
0x73, 0x3F, 0x41, 0x7F, 0x87, 0x56, 0xF2, 0x69,
0xAD, 0x26, 0xB0, 0x54, 0xEF, 0xF7, 0xDF, 0x26,
0x99, 0x0E, 0xAA, 0x54, 0x65, 0x63, 0x96, 0x33,
0x1F, 0x12, 0x91, 0x25, 0x4A, 0x05, 0x10, 0xF8,
0xCA, 0x98, 0x78, 0x79, 0x2F, 0xA1, 0xAE, 0xF0,
0x83, 0x7E, 0xEB, 0xAF, 0x35, 0x0A, 0x0C, 0xC2,
0x7C, 0x3F, 0xE5, 0x21, 0x9E, 0x7C, 0x65, 0x4A,
0x8A, 0x20, 0xEA, 0x68, 0x4B, 0x62, 0x39, 0x74,
0x7B, 0x48, 0xBC, 0x62, 0xF0, 0xB0, 0x5B, 0x86,
0x07, 0x8A, 0x9C, 0xED, 0x18, 0x0A, 0xF8, 0x63,
0x4E, 0x3D, 0xF9, 0x8C, 0xF1, 0xC6, 0x56, 0xA4,
0xC5, 0x6E, 0xCC, 0x76, 0x5D, 0x03, 0x29, 0x2C,
0xD1, 0x17, 0xE9, 0x84, 0xB5, 0x41, 0x18, 0xDD,
0x4E, 0x7C, 0x4B, 0xA0, 0x97, 0xE3, 0x99, 0x3E,
0xAB, 0x90, 0x52, 0x26, 0x7D, 0x26, 0x2A, 0x02,
0x09, 0x70, 0xC2, 0x08, 0x05, 0x12, 0x5B, 0xD7,
0xEF, 0x69, 0xDE, 0x12, 0xAE, 0xA2, 0x10, 0xB5,
0xD9, 0xCE, 0x99, 0xC3, 0x1C, 0x85, 0x20, 0xA7,
0xBA, 0xB3, 0xC4, 0x4C, 0xC5, 0x35, 0xE0, 0xBA,
0xCB, 0x0F, 0xD9, 0x30, 0x29, 0xBD, 0x79, 0xCB,
0xC5, 0x9A, 0xFD, 0x74, 0x33, 0x27, 0x1D, 0xAE,
0xF7, 0xF9, 0x85,
0xDB, 0x03, 0xD0, 0xB9, 0x55, 0x8D, 0x8C, 0x01,
0x06, 0x67, 0x63, 0x37, 0x16, 0x63, 0x86, 0x3E,
0xA7, 0xDA, 0x8D, 0x87, 0x1F, 0xAB, 0x45, 0xAF,
0x06, 0x12, 0x3A, 0x33, 0xD1, 0x64, 0x88, 0x08,
0xD9, 0x3A, 0xF1, 0x8A, 0x14, 0x72, 0xD8, 0x94,
0x88, 0x9B, 0x20, 0xDD, 0x84, 0x05, 0x31, 0xDC,
0xD0, 0x8D, 0x0F, 0x30, 0x49, 0x16, 0x76, 0x21,
0xC8, 0x9E, 0x55, 0x08, 0x7D, 0x45, 0x53, 0x21,
0x18, 0x44, 0x4D, 0xD3, 0x29, 0x07, 0xB8, 0xAF,
0xF4, 0x37, 0x13, 0x20, 0xC7, 0x47, 0xC1, 0xDB,
0x0E, 0xBB, 0x60, 0x90, 0x88, 0x82, 0x0E, 0x1D,
0x1F, 0xBE, 0xB2, 0x4F, 0x8C, 0x27, 0x31, 0x6B,
0xEF, 0x77, 0x0E, 0xB6, 0x62, 0xE7, 0xB6, 0x08,
0xA7, 0x04, 0xC5, 0x31, 0x7E, 0x98, 0xC2, 0xA5,
0xB8, 0xB7, 0xAB, 0xE3, 0xFC, 0xF5, 0x42, 0x2B,
0x52, 0xCC, 0x22, 0x9B, 0x80, 0x96, 0xF3, 0x10,
0xA7, 0xC0, 0x8F, 0xDF, 0xC1, 0x49, 0xA1, 0xDE,
0x72, 0x0E, 0x67, 0xAA, 0x83, 0x91, 0x0C, 0x19,
0x23, 0xE5, 0xDE, 0x0E, 0x17, 0x4E, 0x0F, 0x7E,
0xE4, 0xF2, 0x82, 0xCE, 0xC2, 0xE7, 0x7A, 0xF5,
0x82, 0x0F, 0xCD, 0x27, 0x5F, 0xC7, 0x60, 0x48,
0x77, 0xF5, 0x1B, 0xC2, 0xA2, 0x6B, 0x91, 0xB1,
0x8A, 0x36, 0xA4, 0x9E, 0x01, 0xC3, 0x74, 0xB7,
0x2E, 0x94, 0x73, 0x52, 0xEA, 0xEF, 0x17, 0xD2,
0xFD, 0xE9, 0x05, 0x42, 0x68, 0xD1, 0xD1, 0x99,
0x06, 0x6E, 0x23, 0xC8, 0x11, 0xBB, 0x63, 0x8A,
0x46, 0x42, 0xCC, 0xC7, 0x69, 0x4C, 0x76, 0x48,
0x87, 0x21, 0xDF, 0xE7, 0x71, 0xF3, 0x02, 0x09,
0x1D, 0xBC, 0x05, 0x05, 0x92, 0xDA, 0xF9, 0xED,
0xE5, 0x97, 0x4D, 0xBA, 0x37, 0x39, 0x34, 0x2D,
0xC6, 0xFE, 0x22, 0x0F, 0xA7, 0x70, 0x22, 0xEA,
0x5B, 0x05, 0xB8, 0x37, 0xC2, 0x8F, 0x9C, 0x63,
0x4A, 0x76, 0xBA, 0x03,
0x86, 0xC7, 0x76, 0xE8, 0x37, 0x08, 0xD8, 0x26,
0xED, 0xB8, 0x2C, 0x22, 0xFB, 0x96, 0xE4, 0x2C,
0x3A, 0xB5, 0x54, 0x2C, 0x36, 0x70, 0xDF, 0x52,
0x9E, 0x00, 0x8B, 0x98, 0x97, 0x64, 0x21, 0xCE,
0xB9, 0x17, 0x1C, 0x3E, 0x0D, 0x09, 0x5E, 0xD8,
0x2D, 0x2B, 0x1F, 0xE0, 0x7A, 0x32, 0xD7, 0x8D,
0xD0, 0x75, 0x20, 0xF9, 0x5D, 0x02, 0x7E, 0xD1,
0xA6, 0xAF, 0x34, 0xED, 0x26, 0xA6, 0x75, 0x39,
0x9A, 0x04, 0x9B, 0x56, 0x8B, 0xE2, 0xAE, 0x70,
0xAE, 0x4F, 0x1C, 0x9E, 0x01, 0x81, 0x48, 0x09,
0x7C, 0x3F, 0x82, 0x63, 0x51, 0xE5, 0xFC, 0x6A,
0x7C, 0x9F, 0x44, 0x48, 0xC9, 0x87, 0x8C, 0x80,
0x76, 0xA5, 0x00, 0x0E, 0x5C, 0xE6, 0xA3, 0xC6,
0xED, 0x07, 0xA9, 0x39, 0xAB, 0x18, 0xEB, 0xAC,
0xE1, 0x9D, 0xBC, 0xC2, 0xB1, 0xD4, 0x0A, 0x05,
0x86, 0x68, 0x38, 0x6E, 0xF6, 0x75, 0xD7, 0x60,
0x53, 0x28, 0x44, 0x98, 0x02, 0x4C, 0xBF, 0x1D,
0x85, 0xD0, 0xC2, 0xEB, 0x94, 0x92, 0x06, 0x7C,
0x70, 0xF5, 0x6A, 0xD6, 0xBE, 0xA6, 0x5D, 0x2E,
0x14, 0xC0, 0xEA, 0xE5, 0xE4, 0x0D, 0x78, 0xE0,
0x80, 0xB5, 0xE3, 0xA5, 0x19, 0x0A, 0x8E, 0x82,
0x10, 0x1F, 0x3D, 0x2B, 0xC1, 0x55, 0x8D, 0x23,
0x0C, 0xB5, 0xF0, 0xD1, 0x25, 0x5F, 0x2F, 0x48,
0x84, 0x78, 0x7D, 0x11, 0xEF, 0x2D, 0xC1, 0xFE,
0xDA, 0xD0, 0xA8, 0x10, 0xD9, 0x0D, 0x50, 0x6E,
0x06, 0x22, 0xE0, 0x44, 0x79, 0x6F, 0x3C, 0xFD,
0xEF, 0xBF, 0x83, 0x3F, 0x35, 0x3A, 0xC7, 0x14,
0x71, 0x2C, 0x3B, 0xCB, 0x45, 0xB4, 0x3D, 0xA9,
0x14, 0xD1, 0x2D, 0x9E, 0x5C, 0xA0, 0xE8, 0x08,
0x64, 0xE2, 0xDB, 0x57, 0xBE, 0xAE, 0xEB, 0xE3,
0x73, 0x5D, 0x5C, 0xE0, 0xF6, 0xF3, 0x47, 0x3E,
0xB7, 0x45, 0x56, 0xAB, 0xB1, 0x27, 0x93, 0xBF,
0x2B, 0xE8, 0xD7, 0x0C, 0x06,
0x99, 0x7E, 0x6B, 0xCB, 0x26, 0x72, 0xF8, 0x3A,
0xB6, 0xD6, 0x6C, 0xE8, 0xCF, 0xEA, 0xA8, 0xC3,
0x41, 0x5E, 0x62, 0x0A, 0x34, 0x45, 0x5B, 0x58,
0x73, 0x7C, 0x36, 0x82, 0x37, 0x79, 0x5C, 0xF8,
0x10, 0xDE, 0x95, 0xBD, 0x3C, 0xC5, 0x76, 0x6E,
0x8E, 0x8D, 0xF2, 0xF7, 0x80, 0xB1, 0x29, 0xEC,
0x47, 0x7B, 0x5A, 0xEF, 0xAD, 0x48, 0xAB, 0x1E,
0x9B, 0x04, 0x89, 0xB1, 0x34, 0x1C, 0xB3, 0x15,
0x15, 0x0F, 0xBC, 0x80, 0x52, 0xF7, 0xCF, 0xB6,
0xA8, 0x0D, 0x0C, 0xFA, 0xD3, 0xCD, 0x31, 0x9C,
0x31, 0x54, 0xAB, 0xDF, 0x67, 0xC9, 0x75, 0xE6,
0x38, 0x4A, 0xE1, 0x95, 0x02, 0x90, 0xF2, 0x40,
0xA1, 0xE1, 0x9E, 0x7B, 0xC7, 0x66, 0xEF, 0x33,
0x6A, 0x67, 0x2E, 0xC1, 0x59, 0xDE, 0x15, 0xE7,
0xA7, 0xC5, 0x32, 0xD3, 0x4F, 0xA4, 0xCF, 0x09,
0x96, 0xC0, 0xE5, 0x84, 0x77, 0x9E, 0x08, 0x73,
0x83, 0xFE, 0x73, 0x2F, 0xB4, 0x03, 0x88, 0xAF,
0x73, 0x47, 0xB1, 0xBE, 0x76, 0xF3, 0x01, 0xCD,
0x9B, 0xDA, 0x08, 0x0B, 0x20, 0x00, 0x4A, 0x54,
0xA8, 0xD5, 0x99, 0xC7, 0xCD, 0x46, 0x0A, 0x3F,
0xDE, 0x27, 0x2F, 0xDD, 0xE9, 0x58, 0xA2, 0x7D,
0xF9, 0x59, 0xC2, 0xA8, 0x25, 0x8B, 0x20, 0x32,
0xF5, 0x09, 0x2C, 0x59, 0xBA, 0xAE, 0x76, 0x3C,
0x9F, 0x59, 0x22, 0xD6, 0x6E, 0x6D, 0xAE, 0x76,
0x85, 0x84, 0xDB, 0xCA, 0x1D, 0xEF, 0xCF, 0xA5,
0x39, 0x74, 0x49, 0xE2, 0x9F, 0x4A, 0x6E, 0x2B,
0x2E, 0x4F, 0x1B, 0x1A, 0x90, 0x5F, 0xA8, 0x35,
0xBC, 0x4D, 0xEC, 0x06, 0x17, 0x96, 0x08, 0xD1,
0x8B, 0x28, 0x8E, 0x3A, 0x8B, 0x05, 0x2A, 0x34,
0xA2, 0xEF, 0xBA, 0x51, 0xEE, 0x42, 0xA5, 0xC5,
0x35, 0xFA, 0xDA, 0x75, 0xFF, 0x53, 0x7A, 0x3F,
0x53, 0xED, 0x06, 0x0C, 0xBF, 0xAC, 0x4F, 0xA5,
0x43, 0xAB, 0x2B, 0x2F, 0xD1, 0x2C,
0x40, 0xD7, 0xCB, 0xD4, 0xB8, 0xB4, 0x5F, 0x6B,
0xDC, 0x5D, 0x96, 0xB9, 0xC7, 0x02, 0xF4, 0x49,
0xF0, 0xED, 0xB2, 0x55, 0xE4, 0x09, 0xC0, 0x33,
0x95, 0x54, 0xDF, 0xF9, 0xD5, 0x30, 0x0E, 0x8A,
0xBB, 0xDF, 0xEB, 0xFF, 0x27, 0x02, 0x1C, 0xA5,
0x43, 0x84, 0xB4, 0x46, 0x47, 0x0F, 0x8C, 0x81,
0x63, 0x80, 0x6A, 0x84, 0xB4, 0xDD, 0xBC, 0x3E,
0x5D, 0x7E, 0x95, 0x71, 0x06, 0xCA, 0x61, 0x97,
0xDA, 0x80, 0x52, 0x8B, 0xEF, 0x57, 0xCF, 0xFF,
0x39, 0x9C, 0x2C, 0xE2, 0x64, 0xDA, 0xEE, 0xF6,
0x1F, 0xEC, 0xA0, 0x68, 0xBF, 0x4A, 0x30, 0x3B,
0x74, 0xCF, 0x42, 0x2B, 0x0B, 0x84, 0x68, 0x17,
0x37, 0xFD, 0x05, 0x8E, 0xD0, 0xE6, 0x91, 0x30,
0xD3, 0xE5, 0xE7, 0xEE, 0xFD, 0x19, 0x50, 0xF0,
0xCD, 0x13, 0xD3, 0x3F, 0x35, 0x44, 0x12, 0x38,
0xA2, 0xE8, 0x47, 0xD0, 0xF2, 0xD4, 0x43, 0x46,
0xD3, 0xF1, 0x7D, 0x6C, 0xE2, 0x6B, 0x69, 0x8A,
0x35, 0xA9, 0x80, 0xA3, 0x27, 0x8F, 0x23, 0x46,
0xC8, 0x42, 0x4A, 0x16, 0x89, 0xD3, 0x1B, 0x29,
0x30, 0xB1, 0x63, 0x34, 0x2D, 0xCF, 0x72, 0x19,
0x66, 0x69, 0x24, 0xB2, 0x7D, 0x9B, 0x45, 0xB4,
0xFB, 0x9F, 0x5D, 0x28, 0x79, 0x00, 0x2D, 0x93,
0x47, 0x6C, 0xF4, 0x9D, 0x45, 0x59, 0x60, 0x25,
0xC4, 0x7A, 0x6E, 0x67, 0x39, 0xCA, 0xF7, 0x6E,
0x64, 0x31, 0x1E, 0xFE, 0x27, 0x37, 0x78, 0x28,
0x44, 0x7A, 0x61, 0xA3, 0x59, 0x31, 0xEF, 0x2B,
0x94, 0xC3, 0x18, 0xEC, 0x03, 0xFD, 0xD7, 0x30,
0x01, 0x7D, 0x28, 0x9A, 0xB6, 0x1C, 0x31, 0x51,
0x66, 0xCE, 0x9E, 0x53, 0xE9, 0x6F, 0x4C, 0xD7,
0xE0, 0x23, 0x2A, 0xB4, 0xEB, 0xD9, 0x09, 0x06,
0x20, 0x68, 0xC9, 0x28, 0xC4, 0xDE, 0xD0, 0x40,
0xD4, 0x60, 0x09, 0x6A, 0x38, 0x83, 0xBC, 0xB1,
0xD5, 0x49, 0x29, 0x05, 0xD6, 0x2B, 0x70,
0x14, 0x01, 0xDB, 0x36, 0x56, 0xDC, 0xB5, 0x5B,
0x83, 0xCE, 0xAE, 0x7B, 0x08, 0x4D, 0xAF, 0x28,
0x27, 0x10, 0xE4, 0x9F, 0x1E, 0x0A, 0x55, 0xE8,
0x26, 0x14, 0x23, 0xEB, 0x83, 0xEA, 0x15, 0xA6,
0x77, 0x52, 0x71, 0xC5, 0x4C, 0x72, 0xA7, 0xC5,
0xBA, 0xD0, 0x8C, 0x2D, 0x2A, 0x9F, 0xCC, 0x07,
0x28, 0x33, 0x17, 0x88, 0xD3, 0x18, 0x76, 0x42,
0xB6, 0xA6, 0x0B, 0xF2, 0xA6, 0x3F, 0x19, 0x9F,
0xE4, 0xEB, 0xC1, 0x61, 0x0E, 0xD3, 0xD5, 0x03,
0x45, 0xAF, 0xFE, 0x09, 0x89, 0x3A, 0xD3, 0xB8,
0x94, 0x86, 0x98, 0x2B, 0x67, 0x12, 0x4A, 0x6E,
0x5E, 0xFD, 0xEE, 0x5D, 0x27, 0x14, 0x99, 0xD1,
0x3E, 0x5B, 0xE9, 0xCA, 0xA9, 0xEE, 0x69, 0x7B,
0x55, 0x4B, 0xF8, 0xEC, 0x2F, 0x5C, 0x1C, 0xE9,
0xE1, 0x9E, 0x17, 0x7E, 0x5B, 0xB4, 0xFC, 0x91,
0xB7, 0xD0, 0x5C, 0x0D, 0x71, 0xF4, 0xF7, 0x9C,
0x30, 0x10, 0xE3, 0xE9, 0x61, 0xDA, 0xE4, 0x06,
0xCF, 0x2A, 0x2D, 0x99, 0xB3, 0x1E, 0xC5, 0x1D,
0x47, 0xA1, 0x23, 0x37, 0x1A, 0xD2, 0x08, 0x16,
0xE5, 0x0F, 0x7D, 0x55, 0x3D, 0xA4, 0xC8, 0xCD,
0x11, 0xD9, 0x86, 0x2E, 0x37, 0xFC, 0x20, 0x52,
0x91, 0x04, 0x84, 0x94, 0xF6, 0xDD, 0x5B, 0x2E,
0x01, 0xB1, 0xFD, 0x83, 0xFF, 0x41, 0x74, 0xA1,
0x40, 0x8A, 0xA5, 0xA6, 0xB7, 0x56, 0xFA, 0x42,
0x2B, 0x02, 0x1E, 0xFC, 0x4D, 0x29, 0x43, 0x31,
0x70, 0xCD, 0xB6, 0xA3, 0xA0, 0x04, 0xFD, 0x45,
0xE5, 0x91, 0x2D, 0xE1, 0xA8, 0xED, 0xF7, 0xDD,
0x25, 0x54, 0x57, 0x3F, 0x3A, 0x46, 0x76, 0x5B,
0xDC, 0x46, 0xF9, 0x4F, 0x75, 0x6A, 0xBC, 0x4C,
0x6F, 0xA6, 0x37, 0xC7, 0x11, 0x24, 0x57, 0x30,
0x87, 0x75, 0x22, 0x31, 0x36, 0x27, 0x03, 0x78,
0x39, 0x90, 0x1E, 0x5E, 0xCF, 0x88, 0x13, 0x9B,
0xB7, 0x0B, 0x0E, 0x18, 0x5D, 0x31, 0x68, 0xD9,
0xE8, 0xA8, 0x0C, 0x9E, 0xE7, 0xF0, 0x38, 0xED,
0x7F, 0xD0, 0x9D, 0xC7, 0xBC, 0xBA, 0x3F, 0x9F,
0x34, 0x12, 0xCF, 0xF4, 0x4C, 0x30, 0xD3, 0x92,
0x0D, 0x5B, 0xBA, 0xAC, 0x3A, 0xEE, 0xC2, 0x16,
0xFC, 0x21, 0x72, 0xD3, 0x69, 0xBB, 0x4F, 0x29,
0x06, 0x24, 0xBD, 0x53, 0xD1, 0x52, 0x89, 0xD3,
0xE4, 0x83, 0x60, 0x2F, 0x35, 0x03, 0x3E, 0xFA,
0xE4, 0xC3, 0x36, 0xAC, 0xAC, 0x77, 0xE8, 0x42,
0x51, 0x5B, 0x54, 0x41, 0x17, 0xAE, 0x84, 0x0F,
0xF7, 0x67, 0x12, 0x7D, 0x59, 0x34, 0xCB, 0x83,
0x71, 0x00, 0xC9, 0x72, 0xF4, 0x38, 0x8E, 0x48,
0x3A, 0x06, 0x57, 0x6D, 0xC0, 0x8B, 0xAE, 0x35,
0xA9, 0x15, 0xF6, 0x89, 0xEC, 0x32, 0x7D, 0x9A,
0x75, 0xB7, 0x31, 0xF3, 0x01, 0x09, 0x40, 0xFA,
0x10, 0xE5, 0xDE, 0xF7, 0xA4, 0x60, 0x04, 0x00,
0x11, 0x2A, 0xD7, 0x49, 0xD9, 0x14, 0x48, 0x32,
0x0A, 0x28, 0xB7, 0x6B, 0x36, 0x25, 0x94, 0x91,
0xD2, 0xBC, 0x4B, 0xC0, 0x24, 0xE0, 0x16, 0x43,
0x78, 0xB6, 0x1D, 0x9D, 0xDC, 0xB4, 0xB7, 0xF1,
0x81, 0xCB, 0x6C, 0x38, 0x5A, 0x93, 0x94, 0x2F,
0xA1, 0x99, 0x3E, 0xF6, 0x23, 0xFF, 0x02, 0xEF,
0x69, 0xA4, 0xBA, 0x31, 0x31, 0x4F, 0x69, 0xB6,
0x3F, 0x15, 0xFB, 0xB8, 0x3A, 0x79, 0x43, 0x6D,
0xA8, 0x2F, 0xB9, 0xAC, 0xCD, 0x1B, 0xE5, 0x03,
0xC3, 0x1F, 0x4F, 0x07, 0x55, 0x52, 0x6F, 0x38,
0x87, 0x26, 0xD0, 0x29, 0x96, 0xC6, 0x0D, 0x52,
0xAF, 0xCD, 0xC4, 0x3C, 0x31, 0xDB, 0x80, 0xE3,
0xCF, 0x5E, 0xBD, 0x8D, 0x78, 0x91, 0x17, 0x33,
0x01, 0x8B, 0xB9, 0xC0, 0x0F, 0xE0, 0x2D, 0xC4,
0x95, 0xA6, 0xC6, 0xA1, 0x44, 0xBC, 0x08, 0x03,
0x22, 0x9F, 0xDA, 0x0F, 0xAB, 0xE9, 0x8B, 0x21,
0xD6, 0xAA, 0x09, 0x99, 0x17, 0x24, 0x44, 0x18,
0x05, 0x26, 0xFB, 0x22, 0x97, 0x26, 0xA2, 0x71,
0xB6,
0x2D, 0x49, 0xF9, 0x7D, 0x95, 0xD0, 0x2D, 0xF1,
0xE9, 0x19, 0xE1, 0x3D, 0xB7, 0x7B, 0xFE, 0x9C,
0xB1, 0xC8, 0x9E, 0x55, 0x9A, 0x55, 0xF9, 0xFA,
0xA8, 0xAD, 0x6C, 0xDB, 0xAA, 0x73, 0x89, 0x43,
0xCF, 0x5E, 0x57, 0x62, 0x2A, 0xCB, 0x70, 0x35,
0x7B, 0x8E, 0xF4, 0x30, 0xF5, 0x7D, 0x25, 0x06,
0x57, 0x9E, 0x4E, 0x68, 0xB1, 0x4A, 0x67, 0xAB,
0x28, 0x1F, 0xDC, 0xCC, 0xA5, 0x40, 0xC3, 0x73,
0xD0, 0xB8, 0x72, 0x57, 0x40, 0x36, 0x24, 0x34,
0x28, 0x51, 0xCD, 0xB9, 0x02, 0xE9, 0xA9, 0x34,
0xBE, 0x15, 0x24, 0x54, 0x2E, 0x7B, 0xD4, 0x04,
0xA7, 0xFD, 0xC1, 0x2C, 0x96, 0xFF, 0xBF, 0xC1,
0x9B, 0x0F, 0x5D, 0x6B, 0x9B, 0x3D, 0x46, 0x9A,
0x83, 0x1F, 0x1C, 0x62, 0xD1, 0x52, 0x77, 0xD8,
0x18, 0x63, 0x4F, 0x7E, 0x68, 0x59, 0x03, 0xFA,
0x63, 0x05, 0x9F, 0x10, 0xC7, 0xEE, 0x69, 0x0C,
0xB8, 0xCF, 0x5C, 0xAC, 0xE6, 0xF5, 0x47, 0x15,
0x4C, 0x5A, 0x35, 0xCF, 0x4F, 0x4E, 0x85, 0xB0,
0x10, 0xB3, 0x86, 0xCE, 0x07, 0xFD, 0x7B, 0x7E,
0x98, 0xD2, 0xD5, 0xD5, 0x8D, 0xFC, 0x31, 0x30,
0x06, 0x10, 0xA7, 0xBF, 0x21, 0xBC, 0xBB, 0x23,
0x86, 0x26, 0x55, 0x8B, 0x66, 0xB5, 0x24, 0xEC,
0x9A, 0x97, 0xB0, 0x9D, 0x73, 0xA2, 0x63, 0x5F,
0x8B, 0xE3, 0xE5, 0x3C, 0xE4, 0xDB, 0x57, 0x0F,
0x99, 0xAF, 0xC2, 0xB9, 0xA3, 0x7A, 0x8E, 0x9B,
0x43, 0xF4, 0xE1, 0x7D, 0x69, 0xD0, 0xAE, 0x9E,
0x98, 0x17, 0x39, 0x40, 0xDD, 0x8F, 0x92, 0xB9,
0xEA, 0xF1, 0xBB, 0x45, 0x29, 0xB1, 0xA1, 0x13,
0xD7, 0x60, 0xDF, 0x77, 0xAA, 0xBA, 0xC5, 0x74,
0x41, 0xF2, 0x8B, 0x59, 0x85, 0xB3, 0xDB, 0x4D,
0x05, 0xCD, 0x91, 0xD0, 0xC2, 0x6F, 0x17, 0x90,
0x35, 0xDC, 0x23, 0x9A, 0xAB, 0x56, 0x7F, 0x51,
0x07, 0x43, 0x11, 0xA9, 0x2F, 0x64, 0xCA, 0xCC,
0x98, 0x12,
0xFF, 0x42, 0x4F, 0x93, 0xE9, 0xD9, 0x31, 0xAC,
0xF0, 0x74, 0x37, 0x22, 0xE9, 0xE9, 0x15, 0x5C,
0x3D, 0xE7, 0x33, 0x9B, 0x7E, 0x37, 0x2F, 0xF0,
0xCD, 0x2F, 0xDE, 0xF1, 0xB5, 0xEE, 0x49, 0x76,
0xF1, 0x9C, 0xCA, 0x0D, 0x57, 0x51, 0x7E, 0xDF,
0x87, 0xDF, 0xC7, 0x22, 0x6E, 0xF3, 0x1E, 0xD7,
0xD4, 0x04, 0xE2, 0x78, 0xB8, 0x61, 0x84, 0xE5,
0x80, 0xBD, 0x4B, 0x6D, 0xA9, 0x51, 0xAF, 0x87,
0xF1, 0xB3, 0xCA, 0xB2, 0x71, 0x3B, 0x5B, 0x5D,
0xF7, 0x86, 0x79, 0x69, 0x38, 0xF7, 0xA4, 0x7F,
0xCE, 0x35, 0xAA, 0x74, 0x8E, 0xFC, 0x3D, 0xC0,
0x31, 0x49, 0x45, 0x91, 0x39, 0xDA, 0x5F, 0x45,
0x59, 0x62, 0x81, 0x19, 0x4E, 0xF1, 0xE2, 0x0E,
0x92, 0xE4, 0xA9, 0x52, 0x4F, 0xBF, 0x44, 0x6D,
0x67, 0xBC, 0xFC, 0x77, 0x5D, 0x3A, 0x75, 0x8A,
0x7F, 0xB4, 0x1C, 0xFB, 0x63, 0x38, 0x3E, 0x34,
0x63, 0xEA, 0x19, 0x7C, 0x77, 0xA8, 0x98, 0x87,
0x21, 0xDD, 0xD9, 0x58, 0x3C, 0x00, 0xB4, 0x65,
0x98, 0x6A, 0xF6, 0x5C, 0x2F, 0x58, 0x7D, 0x90,
0x14, 0x17, 0xA4, 0x60, 0x78, 0x24, 0xDE, 0x42,
0x01, 0x79, 0xDF, 0x03, 0xB8, 0x10, 0xAE, 0x55,
0xC5, 0x47, 0xFA, 0x93, 0xB2, 0x7C, 0x6C, 0x88,
0xDF, 0xE7, 0xB7, 0x55, 0xAF, 0x6D, 0xED, 0xC2,
0xB9, 0xFF, 0x72, 0xA1, 0x20, 0x76, 0x01, 0xD8,
0x24, 0x64, 0xA6, 0xAB, 0x53, 0xED, 0x50, 0x94,
0xA1, 0x11, 0x49, 0x27, 0x08, 0x7F, 0x86, 0xA5,
0xAB, 0xE2, 0xD4, 0x4B, 0x95, 0x1B, 0x94, 0x55,
0xCC, 0xD3, 0x0A, 0xB0, 0xF5, 0xE6, 0x85, 0xE4,
0x12, 0x0F, 0x16, 0xEE, 0xAE, 0x91, 0x1A, 0x07,
0x85, 0x30, 0xD7, 0x60, 0xE5, 0x6F, 0x7F, 0x25,
0xAD, 0x59, 0x83, 0xC0, 0x61, 0x3F, 0xC2, 0x07,
0xEF, 0xB5, 0xE9, 0xE0, 0x0F, 0x08, 0x2D, 0x3C,
0x9D, 0x3F, 0x57, 0xA6, 0x27, 0x19, 0x6C, 0x61,
0x20, 0xA7, 0xE1,
0x0F, 0x1B, 0xE0, 0x90, 0x99, 0xED, 0xCA, 0x70,
0x73, 0x32, 0xCA, 0xB3, 0x6A, 0xF4, 0x95, 0xED,
0xA6, 0xEC, 0x2C, 0x58, 0xCA, 0xD0, 0x26, 0x47,
0x99, 0x71, 0xB4, 0x83, 0x83, 0x49, 0x63, 0xE0,
0xAC, 0xAB, 0x2D, 0x41, 0x6E, 0x4B, 0x40, 0x28,
0x95, 0xEA, 0xEA, 0x83, 0x22, 0x21, 0x46, 0xF3,
0xC7, 0x15, 0xB3, 0x3C, 0xBC, 0x25, 0x99, 0x4F,
0x04, 0x74, 0x20, 0xF2, 0x94, 0xE2, 0xFC, 0x61,
0xA6, 0xCF, 0x4B, 0x37, 0xD5, 0x2D, 0xFB, 0xAC,
0x16, 0x1C, 0x75, 0xD0, 0x79, 0xA2, 0x2D, 0x20,
0x0E, 0x6C, 0x8B, 0xCC, 0x49, 0x5E, 0x75, 0x40,
0x6F, 0x5D, 0x18, 0xF2, 0x98, 0x84, 0xAD, 0xEE,
0x0D, 0x03, 0xC1, 0x58, 0x8D, 0x00, 0x82, 0x3C,
0xFE, 0x64, 0xF1, 0x8B, 0xBC, 0x3B, 0x41, 0xF2,
0xA1, 0xD2, 0x45, 0x88, 0x6F, 0xAE, 0xCE, 0xE4,
0x3A, 0x33, 0xCC, 0x5C, 0x6F, 0x2D, 0x3E, 0x48,
0x59, 0x1F, 0x53, 0x44, 0x11, 0xD3, 0x53, 0xD9,
0x69, 0x10, 0x40, 0xBA, 0x23, 0x3D, 0x53, 0x61,
0x89, 0x88, 0x45, 0x04, 0x99, 0x7A, 0xD0, 0xDC,
0xE6, 0xCD, 0x32, 0x9C, 0x2B, 0x7D, 0x37, 0x82,
0xD9, 0x64, 0xD4, 0x05, 0x4E, 0xF4, 0xCA, 0x13,
0xB2, 0x02, 0xC6, 0x56, 0xF4, 0x83, 0xF3, 0xBD,
0x7C, 0x53, 0x3C, 0x54, 0x0D, 0x2C, 0x1A, 0x5F,
0x12, 0xDC, 0x4B, 0xE3, 0x46, 0xE0, 0x9B, 0x80,
0xB4, 0x36, 0x73, 0xB2, 0x2A, 0xDF, 0x0C, 0x2E,
0x49, 0xCC, 0x3E, 0x66, 0xBB, 0x00, 0x2E, 0x36,
0xCA, 0xC3, 0x7B, 0x1A, 0x0D, 0x24, 0x95, 0xAB,
0xD3, 0xF6, 0xB1, 0x1C, 0x65, 0x24, 0xB8, 0x4A,
0x60, 0x97, 0x42, 0x9E, 0xFC, 0x94, 0x2A, 0x73,
0xE3, 0xEE, 0x8F, 0xDA, 0x20, 0x21, 0x03, 0x45,
0x5D, 0x06, 0x38, 0x54, 0xBE, 0x2D, 0xA1, 0xC0,
0x97, 0x20, 0xC0, 0xD9, 0x68, 0xE0, 0x09, 0x1F,
0xC3, 0xC9, 0x75, 0xFA, 0xEE, 0x45, 0xE7, 0x6E,
0xD2, 0xE5, 0x14, 0x48,
0xF6, 0x46, 0x0E, 0x28, 0xDE, 0xB9, 0x0B, 0x95,
0x4E, 0xCE, 0xE2, 0x1D, 0xB0, 0xAC, 0x55, 0xCF,
0x43, 0xAF, 0xEC, 0xEF, 0x6E, 0xA0, 0x8B, 0x65,
0x35, 0xA6, 0x6D, 0x21, 0xAB, 0x52, 0xC3, 0xCC,
0xE0, 0xED, 0x0A, 0x7E, 0x64, 0x18, 0xAB, 0x78,
0xB2, 0xCD, 0xBD, 0x69, 0x23, 0x8C, 0x80, 0xE1,
0xA7, 0xC4, 0x2E, 0x81, 0x26, 0x4E, 0x25, 0x20,
0xBD, 0xB6, 0x72, 0x2E, 0xC2, 0x02, 0xB9, 0x96,
0x55, 0xBF, 0x04, 0xB6, 0x56, 0x05, 0x71, 0xA7,
0xA5, 0x89, 0xA5, 0x3E, 0xDB, 0xA4, 0xF5, 0x17,
0x95, 0xE6, 0x5A, 0x6C, 0x81, 0xF0, 0x14, 0x16,
0x87, 0xF3, 0x53, 0x0C, 0xB7, 0xB6, 0x25, 0x58,
0x7B, 0xBD, 0xB5, 0xE4, 0x48, 0x42, 0x3D, 0xDC,
0x7C, 0x17, 0xD3, 0x01, 0x07, 0x60, 0x27, 0x92,
0x7D, 0xB3, 0x3F, 0x21, 0xDC, 0xCC, 0x79, 0xA4,
0x21, 0x9B, 0x54, 0x8B, 0x31, 0x9C, 0x15, 0x79,
0x2B, 0xCC, 0xFA, 0xD7, 0xC6, 0x99, 0x0D, 0xE9,
0x8E, 0x68, 0x64, 0xFF, 0x17, 0xFF, 0x0E, 0x34,
0x51, 0xA1, 0x52, 0xAB, 0xC0, 0xE4, 0x3C, 0xF1,
0x2E, 0x57, 0xF2, 0x0D, 0x9C, 0xCB, 0x36, 0x25,
0xC4, 0xB8, 0x07, 0x2E, 0xAE, 0x0F, 0x75, 0xA7,
0x93, 0xA5, 0x64, 0xB7, 0x18, 0x44, 0xCD, 0x14,
0xC3, 0xED, 0xC8, 0x65, 0xE6, 0x39, 0xA5, 0x4D,
0x5C, 0x8A, 0x80, 0xA5, 0x8F, 0x38, 0xAC, 0x05,
0x16, 0x73, 0x65, 0x62, 0x5C, 0xA2, 0x3D, 0xD7,
0x99, 0x6C, 0x4B, 0x5C, 0xAE, 0xFF, 0x44, 0xE4,
0xE3, 0xC2, 0x7F, 0x9F, 0xE6, 0x82, 0x7B, 0x18,
0x4C, 0x49, 0xED, 0xE0, 0x7B, 0xEF, 0x4E, 0x95,
0x66, 0x28, 0x1A, 0x54, 0x90, 0x66, 0x52, 0x53,
0x71, 0x15, 0x15, 0xE5, 0xF5, 0x7B, 0xFE, 0x6C,
0xC9, 0x7C, 0x25, 0x26, 0xD5, 0xE7, 0x49, 0x79,
0x63, 0x9F, 0x44, 0x6B, 0xCA, 0xD2, 0x2C, 0x06,
0x09, 0xD3, 0xCE, 0xD0, 0x5C, 0x34, 0x08, 0x22,
0xEC, 0x1F, 0xF5, 0xE4, 0xF4,
0x70, 0x87, 0xDE, 0x4D, 0xE1, 0x87, 0x09, 0x7D,
0x3F, 0x04, 0x5E, 0x2E, 0xB9, 0x2E, 0x27, 0x24,
0x6B, 0x4B, 0xAC, 0xB5, 0xBB, 0x7E, 0x22, 0x36,
0x8F, 0x12, 0x6A, 0xE2, 0xC1, 0xA7, 0x03, 0x89,
0x1C, 0xEF, 0x0B, 0x47, 0x1C, 0xDA, 0x22, 0xF3,
0xF8, 0x41, 0x42, 0xF4, 0x3D, 0x38, 0x46, 0x35,
0x49, 0x89, 0x2E, 0x6A, 0x2D, 0x4C, 0xA3, 0x12,
0xBB, 0x0D, 0x29, 0xAB, 0xBA, 0xB7, 0xB4, 0xF1,
0x46, 0xB7, 0xEC, 0x2E, 0x66, 0xB4, 0xD4, 0x56,
0xCF, 0xAD, 0x86, 0x54, 0x40, 0xC9, 0x54, 0xC0,
0xCE, 0xF3, 0x96, 0xAC, 0xA1, 0xC9, 0x99, 0xD5,
0x5C, 0x15, 0x89, 0x18, 0xF3, 0x82, 0x01, 0x26,
0xBC, 0x3F, 0xCF, 0x64, 0xA4, 0x83, 0x90, 0xC2,
0x52, 0xEC, 0xA7, 0x2B, 0xFF, 0xD9, 0x79, 0x35,
0x01, 0x88, 0x9A, 0x0D, 0xF9, 0xD5, 0x87, 0x2A,
0xFF, 0x14, 0xAF, 0xA4, 0xBD, 0x2E, 0x49, 0xDF,
0x8C, 0xA2, 0x46, 0xB9, 0x3D, 0xD0, 0x93, 0xE6,
0xCB, 0x98, 0x5C, 0x38, 0x3B, 0x95, 0x25, 0x92,
0xE1, 0x17, 0x9F, 0xAE, 0x82, 0x21, 0x8A, 0x7F,
0x30, 0x96, 0x9A, 0x91, 0x2D, 0x20, 0xDF, 0x41,
0x60, 0xA1, 0x04, 0xB1, 0xCC, 0x9C, 0xB5, 0x0E,
0xB7, 0xA5, 0xB9, 0x61, 0xDF, 0xBB, 0x0F, 0x3C,
0x92, 0x5A, 0x1D, 0x7E, 0x7B, 0xE5, 0x53, 0x03,
0xB9, 0xAF, 0x7E, 0xCE, 0xEC, 0x3C, 0x40, 0x3B,
0xB9, 0x08, 0x4C, 0x63, 0xF1, 0x8B, 0x31, 0x51,
0xEC, 0x69, 0xEA, 0x4B, 0xB2, 0xA0, 0x4A, 0xCC,
0xE2, 0x13, 0x4A, 0xCC, 0x8C, 0xBF, 0x64, 0x0F,
0x4B, 0xA7, 0x25, 0x6D, 0xB7, 0x6C, 0x99, 0x28,
0x10, 0x15, 0x5D, 0x6B, 0xEA, 0x1A, 0xDB, 0xE6,
0xB6, 0xBD, 0xC6, 0xED, 0x28, 0xC5, 0x13, 0xEB,
0x54, 0x2C, 0xE3, 0x90, 0x44, 0x37, 0x11, 0x7A,
0x3E, 0x15, 0xFA, 0xA9, 0xB8, 0x5A, 0x63, 0x38,
0x89, 0xD0, 0x08, 0x7A, 0x63, 0xC6, 0xB6, 0xB9,
0x0B, 0x6A, 0x04, 0x18, 0x6D, 0x68,
0x92, 0x18, 0xFE, 0x70, 0xE0, 0x13, 0xB1, 0xFF,
0xA5, 0xFC, 0x57, 0x8B, 0x3A, 0x1F, 0xB4, 0x98,
0x20, 0x27, 0xBD, 0xD2, 0x9C, 0xDC, 0x6D, 0x12,
0x70, 0x3C, 0x5C, 0x0A, 0xB9, 0x0C, 0x09, 0xB2,
0x63, 0x2E, 0x47, 0xDB, 0xC6, 0x97, 0xCE, 0xA5,
0xB8, 0x5C, 0x22, 0x59, 0x69, 0xDC, 0xBD, 0x25,
0x24, 0x27, 0x81, 0x7A, 0xD4, 0xF2, 0xED, 0x35,
0xF2, 0xB2, 0x66, 0x2B, 0xD7, 0x38, 0xC4, 0xBB,
0xC0, 0x57, 0x6F, 0x4E, 0x48, 0xF6, 0xB5, 0x68,
0x62, 0xDD, 0x7D, 0xF9, 0x5D, 0x9A, 0x46, 0x34,
0xC1, 0x8D, 0xAF, 0x84, 0xFE, 0x1A, 0xD9, 0x52,
0x2E, 0x46, 0xED, 0x5B, 0xD9, 0x2A, 0xBA, 0xC0,
0xA8, 0xDF, 0xD0, 0xE2, 0x35, 0xB4, 0xEE, 0x70,
0x51, 0xA5, 0x72, 0x97, 0x99, 0xCB, 0xA9, 0x1F,
0xD8, 0x99, 0x84, 0xD5, 0xAB, 0xC4, 0x86, 0xAA,
0xDA, 0x28, 0x5A, 0x99, 0xDF, 0x7E, 0x09, 0x9E,
0x27, 0x6D, 0x52, 0xF1, 0x81, 0x4A, 0xDB, 0x7B,
0x6F, 0x96, 0xB8, 0x02, 0xA8, 0xB8, 0xAD, 0xFE,
0x16, 0x0F, 0xF5, 0xBD, 0x7C, 0x2C, 0x29, 0x06,
0x17, 0x61, 0xE5, 0xDA, 0x49, 0xC9, 0xF2, 0x2D,
0xC7, 0x6D, 0x72, 0x6C, 0x27, 0x6C, 0xCD, 0x3C,
0xFB, 0xA7, 0xD4, 0x97, 0x38, 0x90, 0xC1, 0xE0,
0x23, 0xD0, 0x8E, 0xEB, 0xAB, 0xB1, 0x76, 0x00,
0x18, 0xBD, 0xAB, 0xE2, 0x95, 0x43, 0xA6, 0x6E,
0x3C, 0x6A, 0x54, 0xAA, 0xFC, 0x39, 0xD2, 0x45,
0xF2, 0xBB, 0xE0, 0xB9, 0x6D, 0x96, 0xDF, 0xFE,
0x6D, 0xD3, 0x87, 0xC1, 0x58, 0x62, 0xCF, 0x7E,
0x70, 0x14, 0x08, 0xB7, 0x9A, 0xCB, 0x2A, 0x47,
0x77, 0xF5, 0x09, 0xE5, 0x86, 0x21, 0xBE, 0xC8,
0xDC, 0x5F, 0xF3, 0xC7, 0xBE, 0x5B, 0x9E, 0x89,
0xF5, 0x57, 0xFD, 0x95, 0x16, 0xCE, 0x48, 0x1E,
0x38, 0x39, 0x5A, 0xE2, 0x95, 0x5F, 0x5A, 0x3F,
0x81, 0x3A, 0xFB, 0xAD, 0x0C, 0xD4, 0x4C, 0x78,
0x6E, 0x17, 0x5E, 0x9F, 0x6A, 0x13, 0x18,
0x4B, 0xB9, 0xDB, 0x1F, 0xBC, 0x05, 0x08, 0x2A,
0x62, 0x8A, 0xC2, 0x7F, 0xE5, 0x19, 0x91, 0xAF,
0xC9, 0x36, 0x51, 0x1C, 0x0F, 0xD0, 0x90, 0xC6,
0xBE, 0x0F, 0x5F, 0x57, 0xE1, 0x81, 0xA3, 0x52,
0x38, 0x91, 0xCF, 0x8A, 0x1D, 0x93, 0x9F, 0x48,
0xEB, 0xF5, 0x87, 0x2E, 0x3B, 0x1A, 0xBF, 0x85,
0x6B, 0x3E, 0x12, 0x60, 0x03, 0x26, 0xCE, 0x29,
0xA2, 0xC1, 0x2B, 0xF7, 0xD9, 0x80, 0xF3, 0xFC,
0xB9, 0x82, 0x63, 0xD9, 0x49, 0xAB, 0x82, 0xB3,
0x42, 0xA4, 0x7A, 0x5E, 0xDF, 0x08, 0x79, 0x5C,
0xDE, 0xC8, 0x16, 0x42, 0x10, 0x44, 0x9F, 0x8F,
0xBB, 0xC2, 0xCB, 0x51, 0x0E, 0xCC, 0xD2, 0xB8,
0x69, 0x6E, 0x93, 0x7A, 0x55, 0x1D, 0x80, 0x0C,
0x08, 0x96, 0xC0, 0xD0, 0xF7, 0x7C, 0x25, 0xC6,
0x9A, 0xE1, 0x65, 0xF5, 0x54, 0xC8, 0x05, 0xBC,
0x50, 0x99, 0xE0, 0xCD, 0xE4, 0x94, 0x8B, 0x87,
0xEA, 0x8C, 0x11, 0xB1, 0x9D, 0xDA, 0x31, 0xF8,
0xE1, 0x47, 0x9B, 0x6C, 0x5D, 0xB4, 0x9C, 0xB3,
0x2F, 0x41, 0xB0, 0x70, 0x8D, 0x59, 0xB0, 0x4A,
0xD4, 0x4D, 0xA7, 0xCE, 0xA7, 0xF8, 0xB4, 0x32,
0x79, 0x17, 0xDA, 0x99, 0xEE, 0x80, 0x09, 0x24,
0x0C, 0x53, 0x39, 0x79, 0xEA, 0xFE, 0x4A, 0x78,
0x2C, 0x4A, 0x3E, 0x03, 0x14, 0xCB, 0xBC, 0x16,
0xC8, 0xE5, 0x7F, 0xEC, 0x4D, 0xDA, 0x60, 0xC4,
0xE6, 0xAB, 0xED, 0x85, 0x7D, 0x0F, 0x16, 0x51,
0x69, 0x3D, 0xDB, 0xC2, 0x98, 0x6E, 0x8B, 0x23,
0xEF, 0xB4, 0x9D, 0xBD, 0x68, 0x73, 0x78, 0x09,
0xB6, 0x5D, 0xFE, 0x90, 0x3B, 0x75, 0xF8, 0x27,
0x01, 0xD0, 0x9E, 0xAD, 0x0B, 0x20, 0xF6, 0x10,
0x92, 0xC4, 0x34, 0xD1, 0x77, 0x8E, 0xE9, 0xB3,
0x05, 0x0E, 0xFE, 0x14, 0xBB, 0xD6, 0x28, 0x49,
0xD5, 0x79, 0xF4, 0x7D, 0x4D, 0xF5, 0xCD, 0xB7,
0x64, 0x9D, 0x39, 0x1E, 0x9E, 0xB6, 0xE5, 0x2B,
0x02, 0xFF, 0xEC, 0xB3, 0x8E, 0xCD, 0x24, 0x92,
0xDB, 0x51, 0xEC, 0xC5, 0x3A, 0x50, 0x7D, 0xCF,
0xD0, 0x9C, 0xD3, 0x06, 0x97, 0x4F, 0xCE, 0xBB,
0x6E, 0x30, 0xE8, 0xB7, 0xE4, 0x91, 0x67, 0x87,
0xCD, 0xAF, 0x69, 0x24, 0xB3, 0x0A, 0xE5, 0x71,
0xE2, 0xA3, 0xC5, 0x79, 0xBC, 0x4F, 0x5F, 0x4A,
0x32, 0xA7, 0x7E, 0xE5, 0x92, 0x7F, 0x05, 0xBC,
0x0F, 0x2A, 0xA3, 0x40, 0xC4, 0x90, 0x88, 0x45,
0x3B, 0xF3, 0xE4, 0x74, 0x9E, 0x16, 0x88, 0xD2,
0x39, 0xE9, 0x2D, 0xB5, 0x0C, 0x0E, 0xD7, 0xF5,
0x73, 0x88, 0xCB, 0x17, 0x24, 0xAB, 0xD9, 0x7A,
0x2D, 0x05, 0x79, 0x35, 0xFB, 0xB6, 0x90, 0x83,
0xE4, 0x81, 0x10, 0x30, 0x96, 0x5C, 0x9A, 0xE3,
0xA4, 0x03, 0xFC, 0xE7, 0xFF, 0x83, 0x93, 0x6F,
0xAA, 0xEC, 0x8D, 0xF2, 0x87, 0xB9, 0x43, 0x31,
0x59, 0x01, 0x87, 0x22, 0x73, 0xE2, 0xB4, 0x4C,
0x4C, 0xF2, 0x42, 0x0D, 0xE3, 0x4B, 0x83, 0x49,
0xDB, 0xA2, 0xDC, 0xA7, 0x11, 0xF5, 0x9E, 0x10,
0xF3, 0x43, 0x89, 0x1B, 0x36, 0xF5, 0x86, 0x5E,
0xFB, 0xD3, 0x9C, 0x5D, 0x17, 0xF5, 0xEB, 0xA6,
0xAE, 0x2C, 0x68, 0xAA, 0xD5, 0x5D, 0x7A, 0xE5,
0x10, 0x69, 0xAB, 0x21, 0x75, 0x95, 0xED, 0xD4,
0x87, 0xCD, 0xFE, 0x4C, 0x39, 0x64, 0xB6, 0x4A,
0x77, 0x42, 0xC5, 0x52, 0x89, 0x9F, 0x10, 0x91,
0x7A, 0x61, 0x9C, 0xAA, 0xCA, 0xDB, 0x02, 0xD6,
0x88, 0x8F, 0xB0, 0x54, 0xFE, 0x11, 0xF1, 0xFD,
0x56, 0x4E, 0x01, 0x0D, 0x3D, 0x4B, 0x61, 0x89,
0x47, 0x36, 0x00, 0x38, 0x46, 0x02, 0x4A, 0x2F,
0x7A, 0xB7, 0xAA, 0x9F, 0xB6, 0x12, 0xB8, 0xCA,
0xE5, 0x55, 0x7F, 0xA4, 0xC7, 0xE6, 0x17, 0xF2,
0xA7, 0xB0, 0x05, 0xC6, 0x43, 0x9E, 0xFD, 0xF6,
0x7E, 0xE0, 0x9B, 0x37, 0x38, 0xCB, 0x35, 0x51,
0x2F, 0x6C, 0x70, 0x96, 0x80, 0x51, 0xC4, 0x74,
0x6C, 0xC5, 0x2F, 0xAA, 0x6A, 0xE5, 0x9B, 0x0C,
0xE2, 0x88, 0xF3, 0x13, 0xED, 0x12, 0xD0, 0xC3,
0xBE,
0xA3, 0x50, 0xA1, 0x42, 0x9F, 0xFA, 0x9E, 0xC8,
0x36, 0x6F, 0xDB, 0x39, 0x24, 0x5A, 0x8A, 0x24,
0xEF, 0xF1, 0x08, 0x3E, 0x20, 0x81, 0xDF, 0x4E,
0x72, 0x02, 0xD3, 0xB0, 0xAD, 0x38, 0xC5, 0x77,
0x0B, 0x35, 0x3D, 0x6A, 0x50, 0x5B, 0xD4, 0x09,
0x7F, 0x47, 0xA0, 0xF7, 0x27, 0x4C, 0xE1, 0x02,
0xF6, 0xF6, 0x90, 0x1C, 0x7B, 0xB4, 0x19, 0x79,
0xCC, 0xCA, 0x0E, 0x8E, 0x89, 0xF0, 0x5C, 0x0E,
0x46, 0x87, 0x94, 0x33, 0x7F, 0x90, 0x5C, 0x97,
0x89, 0x84, 0x89, 0x73, 0xBE, 0x33, 0xED, 0xC4,
0xA6, 0x4D, 0xA1, 0x12, 0x5A, 0x61, 0x18, 0x30,
0x11, 0xB0, 0xB5, 0x84, 0xC5, 0xE9, 0x81, 0x05,
0xA6, 0x4E, 0x83, 0x20, 0x67, 0x3F, 0xC0, 0xF6,
0x4B, 0xD0, 0x2B, 0x4A, 0xF2, 0xF4, 0x88, 0xA8,
0x87, 0x1B, 0xBA, 0x01, 0x81, 0x07, 0x72, 0xB5,
0xB7, 0x95, 0xE1, 0x93, 0x8C, 0x8F, 0x5D, 0x46,
0xB9, 0xC5, 0xD2, 0xEC, 0xAC, 0xEB, 0x82, 0x49,
0xCE, 0xF0, 0x89, 0x28, 0xCF, 0xC6, 0x06, 0x14,
0xD1, 0x52, 0xDE, 0x63, 0xFB, 0xC0, 0xCF, 0x19,
0x26, 0x88, 0x11, 0x34, 0x39, 0x02, 0xB3, 0x09,
0x4F, 0x7D, 0x51, 0xB2, 0x40, 0x96, 0x23, 0x8C,
0xB6, 0x91, 0xE1, 0x4C, 0xB3, 0x85, 0x2E, 0x7F,
0xA3, 0x72, 0xFD, 0xBE, 0xE8, 0x7B, 0xDE, 0xA4,
0x58, 0x1A, 0x11, 0xEC, 0xE6, 0xA1, 0x36, 0x4A,
0x4D, 0x68, 0x0B, 0x03, 0x35, 0xE8, 0x53, 0x94,
0x9D, 0x97, 0xD5, 0x6D, 0x61, 0x48, 0x16, 0x6C,
0xAC, 0xF3, 0x2A, 0x7F, 0x9E, 0x3A, 0xBB, 0x5F,
0xA3, 0x99, 0x4A, 0x5C, 0xAC, 0xB0, 0xB2, 0xAA,
0x9C, 0x4C, 0x5B, 0xCE, 0x34, 0xFC, 0x1C, 0xE9,
0xD6, 0xC7, 0xC1, 0xEA, 0xAB, 0x87, 0x10, 0xBA,
0x46, 0x61, 0x28, 0xB4, 0xB1, 0x46, 0x32, 0x24,
0x7E, 0x33, 0xF0, 0x24, 0x7F, 0xAA, 0xCD, 0x14,
0x6D, 0xAA, 0xB5, 0xD5, 0x11, 0xA9, 0x98, 0x90,
0x4F, 0xDD, 0x0F, 0xDC, 0xD9, 0x8B, 0xB6, 0x30,
0xCA, 0x6D,
0xED, 0x97, 0x39, 0x35, 0x61, 0x09, 0x47, 0xA0,
0xF7, 0xB4, 0xFD, 0x0F, 0xA4, 0x21, 0xC9, 0x3A,
0x31, 0x6A, 0x94, 0x12, 0xBB, 0x6F, 0xE8, 0x7A,
0x0A, 0x4E, 0xD5, 0xD3, 0x6D, 0xA2, 0x46, 0xB1,
0xD2, 0xEE, 0x84, 0xA6, 0xA6, 0xC8, 0x21, 0x08,
0xE7, 0xAC, 0xE9, 0x3B, 0xEC, 0x83, 0x17, 0x90,
0x40, 0x55, 0xDD, 0xD7, 0xC3, 0x60, 0x18, 0xD4,
0x83, 0x15, 0x04, 0x81, 0xCF, 0x99, 0x10, 0xD1,
0x7C, 0x52, 0x83, 0xAD, 0xB7, 0x66, 0x85, 0xFC,
0x4A, 0xC8, 0x4D, 0xC9, 0x07, 0x94, 0x4F, 0xE2,
0x6C, 0x4D, 0x76, 0x1B, 0xDF, 0x50, 0xC4, 0x75,
0xED, 0x4F, 0xEE, 0x05, 0x30, 0x93, 0xB5, 0xFA,
0xD5, 0x62, 0xC9, 0xE6, 0xE8, 0xD7, 0x07, 0x87,
0x8A, 0x01, 0x6F, 0xF5, 0x7E, 0xEE, 0xA6, 0xE1,
0x20, 0xCD, 0x3B, 0xFD, 0xC4, 0xC8, 0x6A, 0x8D,
0x0C, 0x8C, 0x24, 0x50, 0x39, 0x1C, 0xBD, 0x6D,
0x24, 0x78, 0x15, 0x59, 0x9E, 0x9D, 0x18, 0x6B,
0xC5, 0xEE, 0x06, 0x3E, 0xF2, 0x05, 0x3B, 0x9C,
0x5D, 0x5F, 0xB6, 0x7D, 0x59, 0x71, 0x52, 0xD0,
0xEE, 0xB0, 0xD1, 0x96, 0x3A, 0xEF, 0xA4, 0xD5,
0x02, 0xF8, 0x56, 0xC3, 0x19, 0xC1, 0x16, 0xBD,
0xCA, 0xA3, 0xAA, 0x1A, 0x6F, 0xFD, 0x73, 0xDD,
0x13, 0x87, 0x5E, 0xE9, 0x39, 0x9A, 0x4C, 0xCB,
0x6D, 0x2E, 0x89, 0xC3, 0x54, 0xDF, 0x75, 0xF0,
0xAA, 0x1B, 0x64, 0xB8, 0x02, 0x68, 0x7F, 0x24,
0x53, 0xE6, 0x0F, 0xBD, 0xA4, 0xAA, 0x4B, 0x92,
0xBD, 0xA6, 0xF1, 0xD0, 0xBC, 0x8A, 0x54, 0x61,
0xD3, 0x35, 0x5C, 0xB3, 0xE4, 0xD5, 0x30, 0x79,
0x22, 0xFB, 0x74, 0xE3, 0x3F, 0x90, 0x72, 0xD5,
0x05, 0xC3, 0x4B, 0x78, 0x3B, 0xF2, 0x0B, 0xC8,
0x29, 0xDB, 0x8E, 0x5B, 0xF5, 0x83, 0x2B, 0x39,
0x90, 0xE0, 0x53, 0xD9, 0xB8, 0x75, 0x86, 0xA3,
0x2C, 0x12, 0x0A, 0x7D, 0x97, 0xC3, 0xE9, 0x4A,
0x59, 0x19, 0x0C, 0x48, 0x8E, 0x23, 0x92, 0xAF,
0xB6, 0x0B, 0xA7,
0xED, 0x52, 0x36, 0x00, 0xA1, 0x0E, 0x87, 0x13,
0x07, 0x49, 0x28, 0xE6, 0x61, 0xD1, 0xE4, 0x15,
0xA4, 0xC7, 0x1A, 0xA5, 0x09, 0xE6, 0x3E, 0xAA,
0xED, 0x23, 0xAD, 0x95, 0x5A, 0x47, 0x29, 0x5C,
0xC7, 0xB7, 0xBA, 0x85, 0xC9, 0x90, 0x2A, 0x26,
0xD5, 0xC9, 0x67, 0xAC, 0xF1, 0xB2, 0x5A, 0x94,
0x28, 0xB9, 0x31, 0x54, 0xCF, 0xBA, 0xB5, 0x2E,
0x7A, 0x9F, 0xFF, 0x22, 0x5F, 0x74, 0xC5, 0xAC,
0x25, 0xAD, 0xBC, 0xB7, 0x35, 0x46, 0x33, 0xC1,
0x34, 0x43, 0x69, 0xEA, 0xDE, 0xBC, 0x4E, 0xDC,
0x19, 0x4F, 0x6F, 0x45, 0x54, 0xCE, 0xD8, 0x11,
0x81, 0x58, 0x48, 0x11, 0xFD, 0x24, 0x10, 0x83,
0xDD, 0x16, 0x59, 0xBB, 0x48, 0x5A, 0x72, 0x61,
0x39, 0xB1, 0x1C, 0x05, 0x8C, 0xF4, 0xBE, 0x4F,
0xDD, 0xB9, 0xCC, 0x44, 0x2D, 0x87, 0xE6, 0xFE,
0x35, 0x7D, 0x46, 0x67, 0x8B, 0x01, 0x0E, 0x76,
0x9C, 0x8D, 0x81, 0x0B, 0x1E, 0x32, 0xFA, 0x36,
0xAD, 0xF9, 0xEE, 0xAB, 0x91, 0x8B, 0x3B, 0xFA,
0xFB, 0x27, 0xA8, 0x1A, 0x23, 0xF6, 0xC0, 0x3B,
0x67, 0x83, 0x49, 0xC9, 0x52, 0x8B, 0x58, 0x3B,
0x2F, 0x75, 0x92, 0x15, 0xEB, 0x19, 0x09, 0x84,
0xEE, 0x37, 0x5B, 0x13, 0xB8, 0xBA, 0x31, 0xE8,
0x25, 0x6A, 0xDB, 0x72, 0x87, 0x24, 0xE9, 0x95,
0x4A, 0xC8, 0x0C, 0x87, 0xDD, 0x4C, 0x68, 0xB4,
0x63, 0xD0, 0x4B, 0x63, 0xC9, 0x4D, 0xD1, 0x12,
0xC2, 0x5B, 0xE5, 0x92, 0xA4, 0xEB, 0x5B, 0xE5,
0x91, 0x49, 0x82, 0x3C, 0xE2, 0x18, 0xB9, 0xFF,
0x70, 0x7B, 0xA1, 0x07, 0x0E, 0xC1, 0x90, 0x61,
0xAF, 0xA1, 0x60, 0xA1, 0x3A, 0xA5, 0xFE, 0xDB,
0x04, 0x78, 0x7F, 0xDC, 0x64, 0x60, 0x9C, 0x2C,
0x2D, 0xBC, 0xCC, 0x1F, 0xA5, 0x40, 0xF4, 0x4C,
0xFD, 0x87, 0xF8, 0x7E, 0x07, 0xA7, 0x4B, 0x11,
0xF1, 0x16, 0x0A, 0xC4, 0xCE, 0x64, 0x7C, 0x90,
0xDB, 0xA5, 0xE8, 0x80, 0x4C, 0x72, 0x5C, 0x3F,
0x40, 0x4F, 0xE9, 0x0D,
0x05, 0xD7, 0x49, 0x08, 0xE1, 0xBA, 0x8F, 0xB5,
0x58, 0x75, 0xCD, 0xCE, 0x0D, 0x73, 0x6A, 0x9C,
0x59, 0x60, 0xCD, 0x06, 0x42, 0xD6, 0xFE, 0x7C,
0x7D, 0xBA, 0xFF, 0xFF, 0xD5, 0x68, 0x51, 0x59,
0x6B, 0xFF, 0x5B, 0x6A, 0x08, 0x3E, 0x95, 0x33,
0x6E, 0xD5, 0x7D, 0x2F, 0x61, 0x14, 0xE7, 0x5D,
0x11, 0x43, 0xF8, 0x85, 0x81, 0x8B, 0x58, 0xD8,
0x2D, 0xBB, 0xFD, 0xC2, 0x71, 0xC4, 0x2C, 0xE5,
0xEA, 0x42, 0x11, 0x0F, 0x02, 0x4A, 0x4F, 0xF3,
0xC5, 0x40, 0xAE, 0x56, 0xD3, 0x38, 0x31, 0x04,
0x51, 0xE7, 0x43, 0x19, 0x98, 0xA7, 0x38, 0x55,
0x6C, 0xC7, 0x6C, 0xA0, 0x48, 0xB3, 0xF5, 0xE5,
0x47, 0x78, 0xF8, 0x0D, 0xC0, 0xAE, 0xC9, 0x14,
0xD4, 0x53, 0x9A, 0x33, 0x68, 0x6D, 0xD2, 0xCD,
0x30, 0x4B, 0xC9, 0x05, 0x8D, 0x40, 0x18, 0x75,
0x69, 0xBE, 0x90, 0x82, 0x54, 0xBF, 0x63, 0x35,
0xD6, 0xDA, 0x9D, 0x30, 0xD8, 0x28, 0x2B, 0xDC,
0x23, 0xAA, 0x59, 0x3F, 0xE9, 0x05, 0xA2, 0x8F,
0x67, 0xBC, 0x2C, 0x24, 0x06, 0x18, 0x63, 0x43,
0x52, 0xB5, 0xE4, 0x0A, 0xDE, 0xC3, 0x8E, 0xFF,
0xA1, 0x0E, 0xD0, 0xE0, 0xF6, 0x32, 0x81, 0xAC,
0xDE, 0xC4, 0xEA, 0x6D, 0x91, 0x91, 0xE8, 0x88,
0xD7, 0x6C, 0xFC, 0x00, 0x5C, 0xBA, 0x23, 0xE1,
0x07, 0x0B, 0x30, 0x00, 0xFE, 0x17, 0x7B, 0x67,
0xBD, 0x04, 0x33, 0xA0, 0xEE, 0xC7, 0x56, 0x22,
0x49, 0xAD, 0x73, 0x0F, 0xFB, 0x79, 0x7E, 0x61,
0x39, 0x61, 0x3B, 0x56, 0xAE, 0x0B, 0xBE, 0xCA,
0xAD, 0x95, 0xDE, 0xF2, 0xC4, 0xAC, 0x6C, 0x1A,
0x5D, 0xC5, 0x89, 0xE3, 0x07, 0xC6, 0xDA, 0x4C,
0xCB, 0xCE, 0x08, 0x2F, 0x84, 0x00, 0x84, 0x56,
0xD3, 0x27, 0x56, 0xA7, 0x64, 0x60, 0x7C, 0x82,
0x97, 0x8F, 0x1F, 0x94, 0x42, 0xF9, 0xBB, 0x38,
0x6D, 0x7A, 0xDC, 0x81, 0xB2, 0x34, 0x10, 0xED,
0xEB, 0x2F, 0xF9, 0x93, 0x4A, 0x0A, 0xD6, 0xC8,
0xE4, 0xCF, 0x66, 0x98, 0xFD,
0xFC, 0x06, 0xF2, 0x63, 0xA8, 0x38, 0xF2, 0xC9,
0x4C, 0xFA, 0x9E, 0x70, 0xB7, 0xD9, 0xA0, 0x93,
0xBC, 0x35, 0x91, 0x81, 0x3F, 0x1C, 0x39, 0x45,
0x56, 0x06, 0xCB, 0xE9, 0xCD, 0xAD, 0x04, 0xAA,
0x05, 0xB2, 0xCE, 0x4B, 0x07, 0x9B, 0x50, 0x6E,
0xA8, 0x10, 0x7E, 0x62, 0x8A, 0x97, 0xEA, 0x88,
0x47, 0x4A, 0xF9, 0xDD, 0x82, 0xC1, 0x2B, 0x5E,
0xAD, 0xDB, 0x41, 0x5F, 0xEE, 0x16, 0xF9, 0x83,
0xE7, 0x38, 0xCB, 0x74, 0xD1, 0x48, 0x7E, 0x4D,
0xAE, 0x0F, 0xE0, 0xED, 0x57, 0x0E, 0x69, 0xB3,
0x3A, 0x4A, 0xE9, 0x27, 0x88, 0x33, 0x38, 0xD8,
0x46, 0xC1, 0x09, 0xD2, 0x84, 0x13, 0xC5, 0x4C,
0x38, 0x14, 0x69, 0x1B, 0x96, 0x32, 0x21, 0xAD,
0x61, 0x61, 0x60, 0xFD, 0x2F, 0xC5, 0xE8, 0x17,
0x64, 0x17, 0xE0, 0x62, 0xF3, 0x27, 0x06, 0xDD,
0x25, 0x91, 0xB2, 0x2F, 0xD7, 0xCC, 0xB6, 0x70,
0xDD, 0x1F, 0xBC, 0xFD, 0x4E, 0x45, 0x90, 0x17,
0xA5, 0x66, 0xFC, 0xBB, 0x8C, 0x5B, 0x70, 0xD3,
0x1B, 0x7D, 0x68, 0xF9, 0x53, 0x90, 0x63, 0xD0,
0x12, 0x3F, 0xB4, 0xF4, 0x79, 0x75, 0x30, 0x1C,
0x26, 0xBC, 0xA2, 0x0C, 0x46, 0xB7, 0x16, 0x01,
0x91, 0x07, 0xDC, 0x84, 0x2C, 0x7A, 0xDC, 0x91,
0x5A, 0x18, 0xA4, 0x46, 0xDE, 0x04, 0x55, 0x8C,
0x17, 0x8B, 0x68, 0x9F, 0x35, 0xE8, 0xD8, 0x15,
0x49, 0x42, 0xB5, 0xD2, 0x7E, 0x37, 0x5A, 0x8F,
0xE9, 0x13, 0xB1, 0xFD, 0x39, 0xFA, 0x0A, 0xD5,
0x8E, 0xD6, 0x7D, 0xCC, 0xFC, 0x0A, 0x4B, 0xE9,
0xDA, 0x3A, 0x64, 0xA4, 0x5B, 0x7F, 0x2C, 0x2B,
0xE6, 0x24, 0x71, 0x1D, 0x9A, 0xF0, 0x57, 0x82,
0x91, 0xB0, 0x68, 0xC1, 0x0D, 0x8C, 0x97, 0x96,
0xA9, 0xE5, 0x3F, 0x0C, 0x44, 0xC0, 0xCF, 0x95,
0x8A, 0x01, 0x38, 0x23, 0x07, 0xD3, 0x8B, 0x59,
0x02, 0x27, 0xE0, 0xDD, 0x20, 0xF6, 0x50, 0x20,
0xD7, 0xC3, 0x27, 0xC4, 0xB8, 0xBE, 0x6D, 0x7F,
0x7A, 0x09, 0x05, 0x95, 0x4B, 0xDE,
0xD6, 0x99, 0xBB, 0x51, 0xD8, 0x94, 0x0D, 0x30,
0x0A, 0x8A, 0xB7, 0x7E, 0x4A, 0xBD, 0x7D, 0x1B,
0xC1, 0x83, 0xC8, 0xE6, 0x94, 0xB8, 0xCD, 0x9A,
0x62, 0x10, 0xC5, 0xC0, 0xF3, 0xB1, 0x35, 0xF1,
0x58, 0x70, 0x49, 0xEA, 0x0A, 0x52, 0xE8, 0x8A,
0xA7, 0xEA, 0x7D, 0x32, 0x79, 0x1C, 0x61, 0x4D,
0xAB, 0xA7, 0x1C, 0xC7, 0x80, 0xE2, 0x99, 0x66,
0x8F, 0x60, 0x09, 0xC1, 0x36, 0xDE, 0x4B, 0x00,
0x2B, 0x39, 0xAB, 0x1F, 0xF5, 0xB6, 0xC7, 0x4E,
0x4D, 0x2D, 0x77, 0x36, 0x76, 0x5B, 0xB2, 0xC7,
0x57, 0x7A, 0x4C, 0x35, 0xCC, 0x56, 0xB1, 0x59,
0x19, 0xB9, 0x90, 0x0B, 0x25, 0x2B, 0x23, 0xE1,
0xA1, 0xDE, 0xA6, 0xA0, 0x1E, 0x6E, 0x7A, 0x9E,
0xBF, 0xB0, 0x3B, 0xA2, 0x8B, 0xE2, 0x8A, 0x4A,
0x59, 0x05, 0xC7, 0xB8, 0x39, 0x7A, 0x70, 0x54,
0xEF, 0x29, 0xC9, 0xB5, 0x8C, 0x1C, 0x23, 0x98,
0x17, 0x3A, 0xAD, 0x7C, 0x23, 0x32, 0x50, 0x0C,
0x8C, 0x17, 0x00, 0x4F, 0x7E, 0x2F, 0x8B, 0x0E,
0xE4, 0x4C, 0xA2, 0x7F, 0x16, 0xE1, 0x0E, 0x81,
0x9D, 0x7D, 0x37, 0x4C, 0x3F, 0x47, 0xB0, 0x81,
0x28, 0x8B, 0x4B, 0xC2, 0x8F, 0x7C, 0x08, 0x98,
0x1F, 0x18, 0x89, 0xBB, 0x97, 0x75, 0x54, 0x32,
0xC9, 0xA3, 0x39, 0x5D, 0x4A, 0x83, 0x42, 0xFB,
0x1A, 0x06, 0xC3, 0x25, 0x48, 0x86, 0x6C, 0x7E,
0xD9, 0xEA, 0x7E, 0x61, 0xD1, 0x71, 0xA5, 0x5C,
0x82, 0x88, 0xE3, 0xDA, 0x56, 0xB2, 0x76, 0xCF,
0x53, 0xFE, 0x5E, 0xE5, 0xC2, 0x14, 0xC3, 0x9F,
0x9F, 0xDA, 0x86, 0xE0, 0xDF, 0x3A, 0xBC, 0x80,
0x61, 0x1F, 0x0D, 0x3C, 0x7E, 0x9C, 0x3E, 0x65,
0x7F, 0xF8, 0xF3, 0xC7, 0x09, 0x9B, 0x46, 0xA7,
0xFB, 0x77, 0xF3, 0xA7, 0xFE, 0x0B, 0xB8, 0xB9,
0x0D, 0xCF, 0x7E, 0x8B, 0xF0, 0xB6, 0x56, 0x31,
0x08, 0x79, 0x2B, 0xB2, 0x36, 0xDD, 0x57, 0x6A,
0xAF, 0xED, 0x3F, 0x29, 0x83, 0xA3, 0x21, 0xF1,
0x6F, 0x93, 0x9A, 0x8A, 0xBC, 0x0B, 0xE2,
0x0C, 0x62, 0x03, 0x4B, 0x55, 0x97, 0xC5, 0x5A,
0x2D, 0xFF, 0x64, 0xD9, 0xE9, 0x07, 0xA5, 0xCB,
0x9D, 0xA0, 0xA2, 0x6B, 0x08, 0x96, 0xA0, 0x50,
0x25, 0xF3, 0x97, 0x32, 0xCD, 0x84, 0xA7, 0x1D,
0x36, 0x9B, 0x2F, 0xF2, 0xC2, 0xE4, 0x21, 0x21,
0x37, 0x86, 0xCB, 0x84, 0x6B, 0x06, 0xCE, 0xA3,
0xA2, 0x1C, 0xF5, 0x01, 0xF8, 0x59, 0xAA, 0x55,
0xDF, 0x32, 0x89, 0x96, 0x66, 0x22, 0x34, 0x4A,
0xF7, 0x71, 0x45, 0x4D, 0x1E, 0x50, 0x84, 0x33,
0x20, 0xB6, 0x96, 0x59, 0xE8, 0xFB, 0x28, 0xD0,
0xA1, 0x8B, 0xF6, 0x37, 0xBF, 0xC5, 0x5F, 0x8B,
0x1E, 0x44, 0x9B, 0xFE, 0xCA, 0x6B, 0x69, 0x6C,
0xA2, 0xAD, 0x5B, 0x71, 0x0F, 0xE8, 0xFE, 0x5B,
0xB6, 0xA3, 0x5A, 0x01, 0x97, 0x8D, 0x0C, 0x6F,
0x10, 0x28, 0x11, 0x5A, 0x22, 0x50, 0x1B, 0x41,
0x3A, 0x7A, 0x78, 0x6A, 0xD0, 0x20, 0x22, 0x4D,
0x75, 0xFE, 0x36, 0x66, 0x30, 0xC1, 0x58, 0xAD,
0xAE, 0xE2, 0x43, 0xDC, 0x28, 0x4B, 0xCD, 0xE4,
0xB7, 0xAD, 0xB8, 0x12, 0x9D, 0xA9, 0x60, 0x4D,
0x63, 0xE1, 0x71, 0xE2, 0x27, 0xBA, 0x80, 0xCD,
0xAA, 0xA2, 0x96, 0xE1, 0x76, 0x9B, 0xDA, 0x45,
0x10, 0x83, 0xC9, 0x42, 0x6C, 0x97, 0xD8, 0x02,
0x07, 0xB7, 0xD8, 0x2B, 0xF7, 0x07, 0xEF, 0x28,
0xAE, 0x69, 0x84, 0x39, 0x30, 0xE8, 0xDF, 0x2E,
0xE6, 0xAB, 0xD2, 0x14, 0x8E, 0xDA, 0xEB, 0x7D,
0x02, 0x44, 0xB3, 0xC6, 0xD2, 0x16, 0x4C, 0x01,
0x0A, 0xBD, 0x4E, 0x2A, 0xCA, 0x24, 0x91, 0xA1,
0x36, 0x7C, 0x7B, 0x72, 0xB2, 0xBE, 0x88, 0xF3,
0x73, 0x27, 0xBD, 0xA7, 0x3A, 0xF1, 0x9D, 0xF7,
0x21, 0xA4, 0x43, 0x9C, 0x16, 0x17, 0xB3, 0x95,
0xA0, 0x27, 0xFC, 0xE2, 0x65, 0x3F, 0xD0, 0xB3,
0xA9, 0xDA, 0x44, 0x04, 0x65, 0x84, 0xE8, 0xB7,
0x67, 0xBD, 0xDA, 0x7D, 0xA2, 0xAF, 0xEB, 0x5A,
0x9C, 0x06, 0x8F, 0xDD, 0x11, 0x29, 0x76, 0xF9,
0x58, 0xF5, 0x3B, 0xB8, 0x82, 0x48, 0xF0, 0x37,
0x2E, 0xF3, 0xF4, 0x5D, 0x34, 0xF6, 0xE8, 0x3D,
0x2B, 0xD0, 0xA6, 0xB7, 0x4A, 0xF5, 0x09, 0x55,
0x2B, 0xB1, 0x39, 0x91, 0xF0, 0x9B, 0xEC, 0xFA,
0x40, 0xAE, 0xAC, 0xCB, 0x8C, 0x7C, 0x26, 0x53,
0xB3, 0x70, 0x11, 0x43, 0x25, 0xA4, 0xED, 0xF2,
0x45, 0x42, 0xAF, 0x8E, 0x69, 0x25, 0x81, 0xA0,
0x58, 0x59, 0xC2, 0xCD, 0x35, 0x48, 0x4B, 0xD8,
0xD0, 0x14, 0xAC, 0x32, 0xB6, 0x1F, 0xAD, 0xEA,
0x46, 0xFD, 0xDB, 0x22, 0x9A, 0xCB, 0xC4, 0x60,
0xA0, 0x95, 0xF9, 0x09, 0xF8, 0xD3, 0x41, 0xDC,
0x33, 0xE4, 0x32, 0x22, 0xC8, 0xDE, 0xA2, 0x28,
0xDC, 0x33, 0x23, 0xEA, 0xB0, 0xC9, 0x45, 0x81,
0x6D, 0xA9, 0x90, 0x05, 0xBA, 0x7C, 0x57, 0x31,
0x4B, 0x40, 0xA6, 0xCF, 0x4B, 0xB5, 0x81, 0x2C,
0x7C, 0x50, 0x4A, 0x1F, 0x7E, 0x82, 0x74, 0x31,
0xCF, 0xA0, 0x2D, 0xAB, 0xA2, 0x47, 0x4E, 0xF9,
0xE4, 0xC4, 0x88, 0x75, 0x76, 0x02, 0x6D, 0xEA,
0xCE, 0x25, 0x55, 0xE6, 0x19, 0xB9, 0x41, 0x4D,
0x6C, 0xCB, 0xA7, 0x3A, 0x4E, 0xDA, 0xAF, 0x5C,
0x79, 0xE5, 0x30, 0x32, 0xC9, 0x40, 0x95, 0x27,
0x47, 0x24, 0xEC, 0xF1, 0xF6, 0xCB, 0xF5, 0x2F,
0x4B, 0x0A, 0x0B, 0xFC, 0xAF, 0x4B, 0x58, 0x47,
0x20, 0x41, 0x5D, 0x38, 0x0F, 0xC5, 0xB2, 0x9C,
0x45, 0x89, 0xE6, 0x18, 0xCC, 0x95, 0x35, 0x41,
0x54, 0x47, 0x3A, 0xE6, 0x6E, 0x0C, 0xA5, 0x82,
0x7C, 0xEA, 0x17, 0x66, 0x85, 0x61, 0x39, 0xFD,
0x01, 0xBF, 0x88, 0xDE, 0xA1, 0x07, 0xFC, 0x20,
0x6E, 0x0E, 0x20, 0x8E, 0xF9, 0x34, 0x4E, 0xA4,
0xCE, 0x1B, 0xDA, 0xB4, 0xBB, 0x5A, 0x40, 0x94,
0x77, 0x02, 0xAA, 0x08, 0xF3, 0xDF, 0x0B, 0x1F,
0x7D, 0x1A, 0x07, 0x5E, 0x8A, 0xB9, 0x54, 0x00,
0xED, 0xD3, 0x69, 0xAA, 0x6D, 0x5B, 0xF3, 0xE5,
0x88, 0xEB, 0x66, 0xE5, 0xEF, 0x0B, 0x38, 0x0C,
0x9C, 0xA7, 0x04, 0x8E, 0x87, 0x08, 0x9C, 0x67,
0xA3, 0x26, 0x81, 0x4D, 0x63, 0x42, 0xAF, 0x3C,
0x0F,
0x00, 0xBD, 0xDA, 0xDC, 0x58, 0xB5, 0x9F, 0x21,
0xDD, 0x01, 0x1D, 0x00, 0x87, 0x25, 0x15, 0xDD,
0x26, 0x73, 0xBA, 0x00, 0xF1, 0x7D, 0xC9, 0x49,
0x03, 0x75, 0x8D, 0x2D, 0x65, 0x53, 0xE9, 0xC3,
0xE2, 0x47, 0x83, 0xFC, 0x61, 0x4B, 0x0F, 0x97,
0xFA, 0x83, 0xC6, 0xF7, 0x1C, 0x10, 0x75, 0x7A,
0xCF, 0x65, 0xAF, 0x8A, 0xCC, 0x4C, 0x8A, 0x81,
0xFD, 0x45, 0x33, 0xCF, 0x72, 0xA6, 0x3D, 0x2C,
0x0F, 0x7A, 0xDF, 0x1C, 0xF3, 0x41, 0xC2, 0xB8,
0x49, 0xB5, 0x0E, 0x3D, 0x73, 0x66, 0x30, 0x00,
0x81, 0x13, 0xCC, 0x1A, 0x9C, 0xE7, 0xEF, 0x37,
0x59, 0xC9, 0x60, 0x0F, 0xA8, 0x6A, 0xB9, 0x37,
0xC5, 0x1F, 0x3F, 0xB7, 0x39, 0xB3, 0x5F, 0x9E,
0xE9, 0x44, 0x02, 0x57, 0x6B, 0xDF, 0xB5, 0x77,
0x77, 0x34, 0xF1, 0x59, 0xCC, 0x6B, 0x0B, 0xD3,
0x58, 0x50, 0x32, 0xA9, 0xC9, 0xFA, 0xCE, 0xB9,
0x6D, 0x59, 0x4C, 0x81, 0x71, 0xB1, 0x74, 0xBE,
0xAC, 0x34, 0x95, 0x66, 0xD9, 0xA8, 0xBF, 0xCE,
0x19, 0x8E, 0xBE, 0xCF, 0xDA, 0x2F, 0xD9, 0x2A,
0xA9, 0x84, 0x1B, 0x2D, 0x7E, 0x99, 0xFF, 0xCD,
0x0C, 0x84, 0x8B, 0x7E, 0x80, 0x33, 0x22, 0xC4,
0x69, 0x02, 0xDF, 0x28, 0x6F, 0xAC, 0x0D, 0xED,
0x4B, 0x43, 0xB6, 0xCB, 0x17, 0x12, 0xF6, 0x29,
0xF9, 0x25, 0xF5, 0xA4, 0x6D, 0xA7, 0x63, 0x65,
0x97, 0x1F, 0xDB, 0x39, 0xFC, 0x93, 0x25, 0x90,
0xF4, 0x10, 0xB0, 0x90, 0x40, 0xD7, 0xEA, 0x67,
0xC4, 0xC0, 0x94, 0x67, 0x11, 0x94, 0x27, 0xF1,
0xEE, 0x11, 0x7C, 0xC3, 0xD8, 0xB2, 0xA7, 0xB0,
0xB3, 0x65, 0xF7, 0xEE, 0xB9, 0x66, 0x0E, 0xA8,
0x98, 0xF1, 0xCB, 0x69, 0xF1, 0x94, 0x36, 0xD3,
0xFF, 0x88, 0x23, 0x72, 0x38, 0x99, 0x3D, 0xB0,
0x4F, 0x42, 0x1A, 0x38, 0xA3, 0xCF, 0x2A, 0xD6,
0x6B, 0x46, 0xE5, 0xC9, 0x2E, 0x8A, 0x7F, 0xB2,
0x23, 0x6F, 0x24, 0x83, 0x9C, 0x4B, 0xCC, 0xEF,
0x9A, 0x01, 0x46, 0xEA, 0x0A, 0x59, 0xCD, 0x4D,
0x6C, 0x2E,
0x78, 0xF4, 0x15, 0x37, 0x79, 0x81, 0xAC, 0x40,
0x1A, 0x3C, 0x2C, 0x45, 0x09, 0x5C, 0x35, 0x4B,
0x6B, 0x4A, 0x71, 0xF3, 0x0E, 0x06, 0x82, 0x99,
0x81, 0x61, 0x33, 0xAF, 0x5A, 0x91, 0x60, 0x20,
0x29, 0xC6, 0xF0, 0xAA, 0x84, 0x48, 0xF7, 0x83,
0x11, 0xD0, 0x60, 0x0A, 0xE7, 0x6D, 0x38, 0x6E,
0x6E, 0xD1, 0x5C, 0xBF, 0x05, 0xAA, 0x3C, 0xE0,
0x56, 0x44, 0xC7, 0x01, 0xB8, 0xFC, 0xD6, 0xD4,
0x5B, 0x42, 0x3E, 0xA8, 0x0F, 0x4B, 0x72, 0xF9,
0xEE, 0xEE, 0x61, 0x75, 0x10, 0xF3, 0xC9, 0x40,
0xFF, 0x41, 0x9C, 0xE7, 0xBE, 0x4F, 0x11, 0x79,
0x83, 0xE9, 0xA2, 0xB1, 0xBA, 0xC8, 0x1A, 0x7E,
0xCD, 0x09, 0x37, 0xA4, 0x80, 0x65, 0x18, 0xA8,
0x1F, 0xFE, 0xBA, 0x8D, 0xFD, 0xC3, 0xF4, 0x25,
0x82, 0x90, 0x05, 0x78, 0x5A, 0xBA, 0xAD, 0x64,
0x72, 0xA9, 0x8A, 0x28, 0x2B, 0x4D, 0x60, 0xE1,
0xF1, 0x0E, 0x8C, 0xD8, 0x70, 0x20, 0x1E, 0xAC,
0x67, 0x45, 0x7E, 0x13, 0xD5, 0x3F, 0x7D, 0xAB,
0x76, 0xB8, 0x47, 0xCC, 0x5E, 0xAF, 0x75, 0xF8,
0x3D, 0x72, 0x2A, 0xB6, 0x24, 0xA9, 0x51, 0xAA,
0x58, 0xD2, 0x49, 0xD9, 0x7B, 0x2C, 0x34, 0x86,
0xE1, 0x24, 0x05, 0xC7, 0x82, 0xF6, 0xEB, 0xBE,
0xAD, 0xB9, 0x24, 0x98, 0xA3, 0x0E, 0xAC, 0x97,
0x8D, 0xCE, 0x79, 0x5D, 0xA1, 0x1C, 0xA8, 0xA6,
0xD0, 0xE8, 0x10, 0x48, 0xE6, 0x03, 0x44, 0xB2,
0xBE, 0x8F, 0xC8, 0x9A, 0x52, 0xC3, 0x18, 0x0B,
0xBD, 0x61, 0x29, 0x7D, 0xE5, 0x0C, 0x2E, 0x38,
0xC6, 0x15, 0xFB, 0x77, 0x71, 0x5D, 0x16, 0x27,
0x40, 0x31, 0x7C, 0x7D, 0x67, 0xAF, 0xD5, 0xD0,
0xD6, 0xBC, 0x34, 0x95, 0xF4, 0xA5, 0xA2, 0x83,
0x5A, 0xA5, 0x0F, 0x3A, 0x9C, 0x99, 0xAE, 0x87,
0x2D, 0x22, 0xF5, 0xA1, 0x37, 0x54, 0x0C, 0xBF,
0x86, 0x0F, 0x44, 0x2D, 0x91, 0xAD, 0x70, 0x64,
0xEB, 0xA0, 0x93, 0xB6, 0xE2, 0x36, 0xE0, 0x23,
0xAD, 0x5A, 0xB3, 0x42, 0x1F, 0x69, 0xD6, 0xE4,
0x2F, 0x89, 0xE9,
0xB2, 0x92, 0xA6, 0xC2, 0xB5, 0x5D, 0xEB, 0xD5,
0xB4, 0xA7, 0x78, 0x15, 0xD3, 0x35, 0xDA, 0x5B,
0x03, 0xAC, 0xD0, 0x51, 0x18, 0x50, 0x61, 0x70,
0x0F, 0x50, 0xD2, 0xD8, 0x68, 0xE9, 0x7E, 0xCB,
0xCF, 0x81, 0x9F, 0x4F, 0x07, 0xFF, 0xCA, 0x86,
0xDF, 0xAA, 0x44, 0x8B, 0xAC, 0xD3, 0x55, 0x3F,
0x81, 0x40, 0x0B, 0x1E, 0x97, 0x6B, 0x39, 0xFB,
0x0E, 0x92, 0x57, 0xF8, 0xF8, 0xFE, 0x73, 0xFE,
0x82, 0xA9, 0x62, 0x61, 0x98, 0xDE, 0x14, 0x49,
0xB3, 0x1B, 0xCC, 0x66, 0x24, 0x33, 0x21, 0x5E,
0x27, 0xDC, 0xD6, 0xD1, 0x84, 0x54, 0x2D, 0x89,
0x79, 0xBE, 0x2E, 0x2F, 0x10, 0xE2, 0xE5, 0x0E,
0x78, 0x22, 0x27, 0xBB, 0xE8, 0x4D, 0x2D, 0x43,
0x6B, 0x73, 0x80, 0x00, 0x68, 0x40, 0x45, 0x6D,
0xB0, 0x8D, 0xA4, 0x36, 0x30, 0xF3, 0x23, 0x0C,
0xE7, 0x3A, 0x5C, 0x99, 0xC6, 0x72, 0x12, 0xFD,
0x0E, 0x54, 0x26, 0xAC, 0x5E, 0xB9, 0xFA, 0x04,
0xCD, 0x21, 0x62, 0xE6, 0x36, 0x01, 0x63, 0x70,
0x13, 0x47, 0x75, 0x16, 0xDA, 0xE9, 0xB7, 0xB3,
0x9D, 0x31, 0x32, 0x4B, 0x3C, 0x4E, 0xE5, 0x5D,
0xE0, 0x0A, 0x4D, 0xD8, 0xBB, 0x40, 0xC2, 0x34,
0xC1, 0xD6, 0x18, 0x42, 0xB4, 0xEA, 0x59, 0x7A,
0xF5, 0xF9, 0xD5, 0x46, 0x49, 0x36, 0x3B, 0xC0,
0x72, 0x45, 0x9E, 0xC6, 0xB4, 0xFB, 0xC5, 0x66,
0x6C, 0x8B, 0x97, 0x01, 0xA7, 0x33, 0xAD, 0x88,
0xA4, 0xBF, 0xE4, 0xB7, 0x68, 0xA8, 0xB8, 0x20,
0x4B, 0xEB, 0x3A, 0x2B, 0x42, 0x6E, 0xA2, 0xD7,
0x6A, 0x5B, 0xE9, 0xAD, 0x4C, 0x50, 0xF4, 0x56,
0x7E, 0x36, 0xAA, 0x5D, 0xF4, 0x5F, 0x1D, 0x97,
0x45, 0x52, 0x09, 0xD4, 0xA5, 0xD2, 0xC6, 0x42,
0x2E, 0x14, 0x3E, 0xE1, 0xDB, 0xB1, 0xA3, 0xF4,
0x3F, 0x5D, 0x65, 0x3B, 0x37, 0x21, 0xD4, 0x6B,
0x8D, 0xDE, 0x84, 0x46, 0x82, 0x9B, 0xC3, 0xEE,
0x8A, 0xBA, 0xFF, 0x3F, 0x5A, 0xF6, 0xF4, 0x76,
0xDB, 0xA2, 0x8C, 0xF1, 0x68, 0xBE, 0x72, 0xC7,
0x5E, 0x76, 0x8C, 0xEF,
0x53, 0xF5, 0xCD, 0x4D, 0x8F, 0x7E, 0x78, 0xE1,
0x58, 0xD5, 0x84, 0xA3, 0x88, 0x9C, 0xC7, 0x8A,
0x5F, 0x19, 0x2F, 0xC3, 0x55, 0xFC, 0x64, 0xAB,
0x77, 0x77, 0xDD, 0xE2, 0x30, 0xCF, 0xEC, 0x48,
0x4E, 0x72, 0xB8, 0xBF, 0x9D, 0x6F, 0xA4, 0x41,
0x1D, 0x05, 0xA9, 0x50, 0x85, 0x53, 0x36, 0xE4,
0x80, 0xA8, 0xAB, 0x87, 0xFB, 0xC9, 0xEF, 0x61,
0x36, 0xF3, 0x13, 0xE2, 0xF1, 0xC3, 0x9A, 0x86,
0xA7, 0x25, 0x3B, 0x6B, 0xC3, 0xED, 0x97, 0xBE,
0xDC, 0x8F, 0x66, 0x4D, 0x1A, 0xFF, 0xFC, 0x7A,
0x7B, 0x84, 0x40, 0xA7, 0xE5, 0xAB, 0xBE, 0x0E,
0x41, 0x88, 0xF0, 0x6C, 0x55, 0x12, 0x47, 0xF0,
0x90, 0x77, 0xE3, 0x68, 0x77, 0x67, 0x42, 0x5A,
0x60, 0xD1, 0xB0, 0x96, 0x93, 0x59, 0x35, 0x5E,
0x01, 0xD1, 0xCB, 0x63, 0x19, 0x55, 0x61, 0x06,
0x5B, 0xD0, 0xEE, 0xD2, 0x89, 0x3B, 0x51, 0xA6,
0xEA, 0x04, 0x6B, 0x01, 0xB2, 0xC3, 0xCC, 0x59,
0x99, 0x49, 0x1C, 0x8C, 0x80, 0x7F, 0x42, 0xAC,
0xE3, 0xDE, 0x17, 0xF7, 0xF7, 0x42, 0x86, 0xB2,
0x8A, 0xC4, 0x91, 0x43, 0x29, 0xE6, 0x8C, 0x8E,
0x20, 0x7D, 0xDE, 0xD8, 0x07, 0x55, 0x32, 0xAF,
0xAF, 0x9E, 0x8C, 0x12, 0x7B, 0xAA, 0x68, 0xF2,
0xA6, 0x72, 0xE8, 0x49, 0xB9, 0x68, 0x27, 0x1B,
0xDC, 0xCA, 0xD6, 0x20, 0x73, 0x03, 0x26, 0x75,
0xEA, 0x5C, 0xF5, 0x42, 0x61, 0x9C, 0x33, 0x3A,
0x3A, 0xF5, 0xD5, 0xAA, 0xD7, 0xAE, 0x13, 0xAB,
0x15, 0x2A, 0xFF, 0x8D, 0xDE, 0xA0, 0x0A, 0x02,
0x4B, 0xEC, 0xB6, 0xBD, 0x28, 0x8C, 0xF1, 0x9C,
0x41, 0x34, 0x22, 0x1A, 0x62, 0xD7, 0xD3, 0xD3,
0x4B, 0xE1, 0xAF, 0x7F, 0x91, 0x2C, 0x52, 0x93,
0x65, 0x88, 0xB8, 0x5A, 0xD5, 0xD6, 0xA0, 0x23,
0x45, 0x2A, 0xB5, 0xDF, 0x88, 0x58, 0x18, 0x4E,
0x82, 0x50, 0x3C, 0xBE, 0x64, 0x16, 0xF2, 0x68,
0x49, 0x2E, 0x96, 0x6D, 0x3C, 0xA1, 0x89, 0x50,
0x0F, 0x6B, 0xF5, 0x50, 0x54, 0xA7, 0xD0, 0xB1,
0x22, 0x56, 0x12, 0x60, 0x01,
0xA7, 0xD5, 0xFC, 0x45, 0xA7, 0x79, 0x2D, 0x39,
0x04, 0xD7, 0xA2, 0x54, 0x4B, 0xE9, 0xE3, 0x0C,
0x6A, 0x8E, 0xE4, 0xF2, 0x68, 0xC8, 0x95, 0xB0,
0x73, 0x06, 0xC0, 0x39, 0xEA, 0x82, 0xC2, 0x08,
0x87, 0x42, 0x70, 0x3B, 0x0B, 0x65, 0x7B, 0x0B,
0xF6, 0xDA, 0x49, 0x69, 0x6C, 0x9D, 0x5F, 0xF4,
0x2D, 0x7D, 0x57, 0x0C, 0xB5, 0x9D, 0x4F, 0x9D,
0x68, 0x08, 0xAD, 0x7C, 0x16, 0xDC, 0x40, 0xA6,
0xFB, 0x74, 0x4A, 0x98, 0xD3, 0xBA, 0x59, 0xE6,
0x18, 0xBB, 0xC3, 0x81, 0x7C, 0x84, 0x8C, 0x82,
0x12, 0x29, 0x23, 0x59, 0x9F, 0x36, 0x96, 0x59,
0xFD, 0x07, 0xE4, 0x08, 0xFE, 0x1F, 0xEE, 0x93,
0xFF, 0x3B, 0xFC, 0x8B, 0x57, 0x85, 0x64, 0xF6,
0x6A, 0x5E, 0x61, 0xF1, 0xCF, 0xE4, 0x55, 0x17,
0x03, 0x32, 0x98, 0x1B, 0x3B, 0xF0, 0x5D, 0xA8,
0xF2, 0x7C, 0x58, 0x36, 0x38, 0x51, 0x5C, 0x0B,
0x55, 0x7D, 0x11, 0x24, 0x8A, 0x8A, 0xCA, 0xF3,
0x61, 0x39, 0x79, 0xA6, 0x0C, 0x70, 0x0E, 0x60,
0x13, 0x69, 0x98, 0xD5, 0xE7, 0x6B, 0x46, 0x33,
0xE7, 0x44, 0xA0, 0x9F, 0x7F, 0xE2, 0x86, 0x68,
0xB1, 0xA2, 0xA7, 0xE3, 0xFB, 0x1F, 0x49, 0x38,
0xA2, 0x7F, 0xBC, 0x01, 0x36, 0xE1, 0x06, 0x46,
0x6D, 0x62, 0xC4, 0x36, 0x3A, 0xE6, 0x99, 0x24,
0xAA, 0x14, 0xB1, 0xEB, 0x58, 0x87, 0xA2, 0xDB,
0x81, 0xE0, 0x16, 0x46, 0x45, 0x20, 0x66, 0x0A,
0x70, 0x80, 0x52, 0xA4, 0xDC, 0xBF, 0x34, 0xDC,
0xF3, 0xC3, 0xFB, 0xB6, 0xCD, 0x28, 0x25, 0x69,
0x89, 0x8E, 0xA1, 0x97, 0x46, 0x58, 0xCE, 0xD7,
0xD9, 0xF9, 0x5B, 0x2E, 0x95, 0x95, 0xC4, 0xC9,
0xB0, 0x89, 0x99, 0x42, 0x49, 0xA2, 0x86, 0x49,
0xCE, 0xCC, 0xF7, 0x34, 0x42, 0x65, 0x7F, 0xF4,
0xA2, 0xB3, 0x52, 0x69, 0x9F, 0xF1, 0xBA, 0xA9,
0x3C, 0x8A, 0xBF, 0x77, 0xE6, 0x00, 0x6F, 0x93,
0xC1, 0xC7, 0xFA, 0xEA, 0xD5, 0x0F, 0x63, 0xC6,
0xE3, 0x60, 0xC0, 0x9F, 0x2F, 0x46, 0x4C, 0xDF,
0xB7, 0x54, 0xD4, 0xD2, 0x0A, 0x68,
0x2B, 0xC2, 0xF6, 0xDD, 0xD6, 0xB4, 0x48, 0xEA,
0x19, 0xFC, 0x65, 0x40, 0x79, 0x4C, 0x90, 0xBE,
0xDC, 0x92, 0xC8, 0x61, 0xCD, 0xEC, 0x77, 0x90,
0x5D, 0x57, 0xE1, 0x0B, 0xC7, 0xB1, 0xDF, 0xAD,
0xC1, 0x81, 0x98, 0xF9, 0x24, 0xEC, 0xCB, 0xE6,
0x24, 0xE8, 0x55, 0x5B, 0xA9, 0x40, 0xDD, 0x13,
0xE3, 0x72, 0x18, 0x43, 0xE7, 0xF9, 0x3A, 0x51,
0x83, 0x67, 0x79, 0xEB, 0x2F, 0xB6, 0xDE, 0xB7,
0xF3, 0xC8, 0x5F, 0x61, 0xB4, 0xB4, 0xE1, 0xFD,
0x16, 0xD5, 0xAC, 0xC7, 0xDE, 0xFC, 0x58, 0x25,
0xDE, 0x9C, 0xB6, 0xCE, 0x6D, 0xB5, 0xBB, 0xD2,
0xB7, 0xB4, 0x15, 0x55, 0x28, 0xAE, 0xAE, 0x41,
0xBE, 0x57, 0xCD, 0x76, 0x1C, 0x1C, 0x9E, 0x09,
0x3C, 0x26, 0xE1, 0xE4, 0x98, 0xDE, 0x96, 0xAF,
0x7F, 0xCE, 0xE3, 0x3F, 0x1A, 0x63, 0xCB, 0x68,
0xAA, 0xF7, 0xF1, 0x17, 0xD1, 0xF3, 0xF1, 0xE2,
0x60, 0x4C, 0x05, 0x25, 0x13, 0xF6, 0xA4, 0xF0,
0x3C, 0x2C, 0x8D, 0x1F, 0xCB, 0xF7, 0x05, 0x2D,
0x11, 0x88, 0x68, 0x6B, 0x3A, 0xD6, 0xEB, 0x02,
0x54, 0xA1, 0x3A, 0xEB, 0x9B, 0xD7, 0x92, 0xA8,
0xFB, 0xDB, 0xFC, 0xE2, 0x8D, 0x68, 0x8B, 0x36,
0x2D, 0x56, 0x0C, 0x4F, 0xB1, 0x8D, 0xA5, 0xCE,
0x6E, 0xB8, 0xB6, 0xAD, 0x18, 0x4B, 0x32, 0x55,
0xE0, 0xBD, 0xEB, 0xB9, 0x2F, 0x20, 0xCC, 0x1A,
0x6B, 0x28, 0x63, 0x2A, 0xD1, 0xBC, 0xE7, 0x3E,
0x57, 0x73, 0x81, 0xC9, 0x27, 0xFC, 0xE9, 0x6F,
0x9A, 0x35, 0x89, 0xD4, 0x2D, 0x55, 0xF5, 0x20,
0x20, 0xB4, 0x62, 0xE9, 0x5E, 0x08, 0x6E, 0x9F,
0xA5, 0x12, 0x33, 0x96, 0xDF, 0x2C, 0xD7, 0xFD,
0x10, 0xC4, 0xAA, 0x4E, 0xC4, 0x3D, 0x02, 0x01,
0x4F, 0xBA, 0x94, 0x22, 0x9B, 0xE4, 0x18, 0xD3,
0x00, 0x31, 0xF2, 0xD8, 0xE2, 0x4A, 0xF1, 0xD6,
0x2B, 0x5D, 0xFD, 0x2E, 0xED, 0x42, 0x33, 0x8C,
0x77, 0x3F, 0xCB, 0xF6, 0x91, 0x5F, 0xCA, 0x0D,
0x9D, 0x7D, 0x8A, 0x1E, 0x34, 0xBE, 0xEF, 0x33,
0x54, 0x08, 0x3C, 0x4F, 0x21, 0x46, 0xD4
};
#endif
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
CFLAGS=-O3 -march=corei7-avx -std=c89 -Wall -pedantic -Wno-long-long
all: check bench
debug:
@$(CC) $(CFLAGS) -DNORX_DEBUG -I. -o debug ../../utils/debug.c norx.c
@./debug
@rm debug
bench:
@$(CC) $(CFLAGS) -o bench ../../utils/bench.c norx.c caesar.c
@./bench
@rm bench
check:
@$(CC) $(CFLAGS) -I../ -o check ../../utils/check.c norx.c caesar.c
@./check
@rm check
.PHONY: check debug bench
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
NORX reference source code package - reference C implementations
Written 2014-2015 by:
- Samuel Neves <[email protected]>
- Philipp Jovanovic <[email protected]>
To the extent possible under law, the author(s) have dedicated all copyright
and related and neighboring rights to this software to the public domain
worldwide. This software is distributed without any warranty.
You should have received a copy of the CC0 Public Domain Dedication along with
this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#define CRYPTO_KEYBYTES 32
#define CRYPTO_NSECBYTES 0
#define CRYPTO_NPUBBYTES 32
#define CRYPTO_ABYTES 32
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
NORX reference source code package - reference C implementations
Written 2014-2015 by:
- Samuel Neves <[email protected]>
- Philipp Jovanovic <[email protected]>
To the extent possible under law, the author(s) have dedicated all copyright
and related and neighboring rights to this software to the public domain
worldwide. This software is distributed without any warranty.
You should have received a copy of the CC0 Public Domain Dedication along with
this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#if defined(SUPERCOP)
# include "crypto_aead.h"
#endif
#include "api.h"
#include "norx.h"
/*
the code for the cipher implementation goes here,
generating a ciphertext c[0],c[1],...,c[*clen-1]
from a plaintext m[0],m[1],...,m[mlen-1]
and associated data ad[0],ad[1],...,ad[adlen-1]
and secret message number nsec[0],nsec[1],...
and public message number npub[0],npub[1],...
and secret key k[0],k[1],...
*/
int crypto_aead_encrypt(
unsigned char *c, unsigned long long *clen,
const unsigned char *m, unsigned long long mlen,
const unsigned char *ad, unsigned long long adlen,
const unsigned char *nsec,
const unsigned char *npub,
const unsigned char *k
)
{
size_t outlen = 0;
norx_aead_encrypt(c, &outlen, ad, adlen, m, mlen, NULL, 0, npub, k);
*clen = outlen;
(void)nsec; /* avoid warning */
return 0;
}
/*
the code for the cipher implementation goes here,
generating a plaintext m[0],m[1],...,m[*mlen-1]
and secret message number nsec[0],nsec[1],...
from a ciphertext c[0],c[1],...,c[clen-1]
and associated data ad[0],ad[1],...,ad[adlen-1]
and public message number npub[0],npub[1],...
and secret key k[0],k[1],...
*/
int crypto_aead_decrypt(
unsigned char *m, unsigned long long *mlen,
unsigned char *nsec,
const unsigned char *c, unsigned long long clen,
const unsigned char *ad, unsigned long long adlen,
const unsigned char *npub,
const unsigned char *k
)
{
size_t outlen = 0;
int result = norx_aead_decrypt(m, &outlen, ad, adlen, c, clen, NULL, 0, npub, k);
*mlen = outlen;
(void)nsec; /* avoid warning */
return result;
}
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
NORX reference source code package - reference C implementations
Written 2014-2015 by:
- Samuel Neves <[email protected]>
- Philipp Jovanovic <[email protected]>
To the extent possible under law, the author(s) have dedicated all copyright
and related and neighboring rights to this software to the public domain
worldwide. This software is distributed without any warranty.
You should have received a copy of the CC0 Public Domain Dedication along with
this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#ifndef NORX_NORX_H
#define NORX_NORX_H
#include <stddef.h>
#include <stdint.h>
/* High-level operations */
void norx_aead_encrypt(
unsigned char *c, size_t *clen,
const unsigned char *a, size_t alen,
const unsigned char *m, size_t mlen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce, const unsigned char *key);
int norx_aead_decrypt(
unsigned char *m, size_t *mlen,
const unsigned char *a, size_t alen,
const unsigned char *c, size_t clen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce, const unsigned char *key);
#endif
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
NORX reference source code package - reference C implementations
Written 2014-2015 by:
- Samuel Neves <[email protected]>
- Philipp Jovanovic <[email protected]>
To the extent possible under law, the author(s) have dedicated all copyright
and related and neighboring rights to this software to the public domain
worldwide. This software is distributed without any warranty.
You should have received a copy of the CC0 Public Domain Dedication along with
this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#include <string.h>
#include "norx.h"
#if defined(_MSC_VER)
#include <intrin.h>
#else
#if defined(__XOP__)
#include <x86intrin.h>
#else
#include <immintrin.h>
#endif
#endif
const char * norx_version = "3.0";
#define NORX_W 64 /* word size */
#define NORX_L 4 /* round number */
#define NORX_P 1 /* parallelism degree */
#define NORX_T (NORX_W * 4) /* tag size */
#define NORX_N (NORX_W * 4) /* nonce size */
#define NORX_K (NORX_W * 4) /* key size */
#define NORX_B (NORX_W * 16) /* permutation width */
#define NORX_C (NORX_W * 4) /* capacity */
#define NORX_R (NORX_B - NORX_C) /* rate */
#define BYTES(x) (((x) + 7) / 8)
#define WORDS(x) (((x) + (NORX_W-1)) / NORX_W)
#if defined(_MSC_VER)
#define ALIGN(x) __declspec(align(x))
#else
#define ALIGN(x) __attribute__((aligned(x)))
#endif
#define LOAD(in) _mm_load_si128((__m128i*)(in))
#define STORE(out, x) _mm_store_si128((__m128i*)(out), (x))
#define LOADU(in) _mm_loadu_si128((__m128i*)(in))
#define STOREU(out, x) _mm_storeu_si128((__m128i*)(out), (x))
# if defined(__XOP__)
#define ROT(X, C) _mm_roti_epi64((X), -(C))
#elif defined(__SSSE3__)
#define ROT(X, C) \
( \
(C) == 8 ? _mm_shuffle_epi8((X), _mm_set_epi8(8,15,14,13,12,11,10,9, 0,7,6,5,4,3,2,1)) \
: (C) == 40 ? _mm_shuffle_epi8((X), _mm_set_epi8(12,11,10,9,8,15,14,13, 4,3,2,1,0,7,6,5)) \
: (C) == 63 ? _mm_or_si128(_mm_add_epi64((X), (X)), _mm_srli_epi64((X), 63)) \
: /* else */ _mm_or_si128(_mm_srli_epi64((X), (C)), _mm_slli_epi64((X), 64 - (C))) \
)
#else
#define ROT(X, C) \
( \
(C) == 63 ? _mm_or_si128(_mm_add_epi64((X), (X)), _mm_srli_epi64((X), 63)) \
: /* else */ _mm_or_si128(_mm_srli_epi64((X), (C)), _mm_slli_epi64((X), 64 - (C))) \
)
#endif
#define XOR(A, B) _mm_xor_si128((A), (B))
#define AND(A, B) _mm_and_si128((A), (B))
#define ADD(A, B) _mm_add_epi64((A), (B))
#define U0 0xE4D324772B91DF79ULL
#define U1 0x3AEC9ABAAEB02CCBULL
#define U2 0x9DFBA13DB4289311ULL
#define U3 0xEF9EB4BF5A97F2C8ULL
#define U4 0x3F466E92C1532034ULL
#define U5 0xE6E986626CC405C1ULL
#define U6 0xACE40F3B549184E1ULL
#define U7 0xD9CFD35762614477ULL
#define U8 0xB15E641748DE5E6BULL
#define U9 0xAA95E955E10F8410ULL
#define U10 0x28D1034441A9DD40ULL
#define U11 0x7F31BBF964E93BF5ULL
#define U12 0xB5E9E22493DFFB96ULL
#define U13 0xB980C852479FAFBDULL
#define U14 0xDA24516BF55EAFD4ULL
#define U15 0x86026AE8536F1501ULL
#define R0 8
#define R1 19
#define R2 40
#define R3 63
/* Implementation */
#if defined(TWEAK_LOW_LATENCY)
#define G(A0, A1, B0, B1, C0, C1, D0, D1) \
do \
{ \
__m128i l0, l1, r0, r1; \
\
l0 = XOR(A0, B0); r0 = XOR(A1, B1); \
l1 = AND(A0, B0); r1 = AND(A1, B1); \
l1 = ADD(l1, l1); r1 = ADD(r1, r1); \
A0 = XOR(l0, l1); A1 = XOR(r0, r1); \
D0 = XOR(D0, l0); D1 = XOR(D1, r0); \
D0 = XOR(D0, l1); D1 = XOR(D1, r1); \
D0 = ROT(D0, R0); D1 = ROT(D1, R0); \
\
l0 = XOR(C0, D0); r0 = XOR(C1, D1); \
l1 = AND(C0, D0); r1 = AND(C1, D1); \
l1 = ADD(l1, l1); r1 = ADD(r1, r1); \
C0 = XOR(l0, l1); C1 = XOR(r0, r1); \
B0 = XOR(B0, l0); B1 = XOR(B1, r0); \
B0 = XOR(B0, l1); B1 = XOR(B1, r1); \
B0 = ROT(B0, R1); B1 = ROT(B1, R1); \
\
l0 = XOR(A0, B0); r0 = XOR(A1, B1); \
l1 = AND(A0, B0); r1 = AND(A1, B1); \
l1 = ADD(l1, l1); r1 = ADD(r1, r1); \
A0 = XOR(l0, l1); A1 = XOR(r0, r1); \
D0 = XOR(D0, l0); D1 = XOR(D1, r0); \
D0 = XOR(D0, l1); D1 = XOR(D1, r1); \
D0 = ROT(D0, R2); D1 = ROT(D1, R2); \
\
l0 = XOR(C0, D0); r0 = XOR(C1, D1); \
l1 = AND(C0, D0); r1 = AND(C1, D1); \
l1 = ADD(l1, l1); r1 = ADD(r1, r1); \
C0 = XOR(l0, l1); C1 = XOR(r0, r1); \
B0 = XOR(B0, l0); B1 = XOR(B1, r0); \
B0 = XOR(B0, l1); B1 = XOR(B1, r1); \
B0 = ROT(B0, R3); B1 = ROT(B1, R3); \
} while(0)
#else
#define G(A0, A1, B0, B1, C0, C1, D0, D1) \
do \
{ \
__m128i l0, l1, r0, r1; \
\
l0 = XOR(A0, B0); r0 = XOR(A1, B1); \
l1 = AND(A0, B0); r1 = AND(A1, B1); \
l1 = ADD(l1, l1); r1 = ADD(r1, r1); \
A0 = XOR(l0, l1); A1 = XOR(r0, r1); \
D0 = XOR(D0, A0); D1 = XOR(D1, A1); \
D0 = ROT(D0, R0); D1 = ROT(D1, R0); \
\
l0 = XOR(C0, D0); r0 = XOR(C1, D1); \
l1 = AND(C0, D0); r1 = AND(C1, D1); \
l1 = ADD(l1, l1); r1 = ADD(r1, r1); \
C0 = XOR(l0, l1); C1 = XOR(r0, r1); \
B0 = XOR(B0, C0); B1 = XOR(B1, C1); \
B0 = ROT(B0, R1); B1 = ROT(B1, R1); \
\
l0 = XOR(A0, B0); r0 = XOR(A1, B1); \
l1 = AND(A0, B0); r1 = AND(A1, B1); \
l1 = ADD(l1, l1); r1 = ADD(r1, r1); \
A0 = XOR(l0, l1); A1 = XOR(r0, r1); \
D0 = XOR(D0, A0); D1 = XOR(D1, A1); \
D0 = ROT(D0, R2); D1 = ROT(D1, R2); \
\
l0 = XOR(C0, D0); r0 = XOR(C1, D1); \
l1 = AND(C0, D0); r1 = AND(C1, D1); \
l1 = ADD(l1, l1); r1 = ADD(r1, r1); \
C0 = XOR(l0, l1); C1 = XOR(r0, r1); \
B0 = XOR(B0, C0); B1 = XOR(B1, C1); \
B0 = ROT(B0, R3); B1 = ROT(B1, R3); \
} while(0)
#endif
#if defined(__SSSE3__)
#define DIAGONALIZE(A0, A1, B0, B1, C0, C1, D0, D1) \
do \
{ \
__m128i t0, t1; \
\
t0 = _mm_alignr_epi8(B1, B0, 8); \
t1 = _mm_alignr_epi8(B0, B1, 8); \
B0 = t0; \
B1 = t1; \
\
t0 = C0; \
C0 = C1; \
C1 = t0; \
\
t0 = _mm_alignr_epi8(D1, D0, 8); \
t1 = _mm_alignr_epi8(D0, D1, 8); \
D0 = t1; \
D1 = t0; \
} while(0)
#define UNDIAGONALIZE(A0, A1, B0, B1, C0, C1, D0, D1) \
do \
{ \
__m128i t0, t1; \
\
t0 = _mm_alignr_epi8(B0, B1, 8); \
t1 = _mm_alignr_epi8(B1, B0, 8); \
B0 = t0; \
B1 = t1; \
\
t0 = C0; \
C0 = C1; \
C1 = t0; \
\
t0 = _mm_alignr_epi8(D0, D1, 8); \
t1 = _mm_alignr_epi8(D1, D0, 8); \
D0 = t1; \
D1 = t0; \
} while(0)
#else
#define DIAGONALIZE(A0, A1, B0, B1, C0, C1, D0, D1) \
do \
{ \
__m128i t0, t1; \
\
t0 = D0; t1 = B0; \
D0 = C0; C0 = C1; C1 = D0; \
D0 = _mm_unpackhi_epi64(D1, _mm_unpacklo_epi64(t0, t0)); \
D1 = _mm_unpackhi_epi64(t0, _mm_unpacklo_epi64(D1, D1)); \
B0 = _mm_unpackhi_epi64(B0, _mm_unpacklo_epi64(B1, B1)); \
B1 = _mm_unpackhi_epi64(B1, _mm_unpacklo_epi64(t1, t1)); \
} while(0)
#define UNDIAGONALIZE(A0, A1, B0, B1, C0, C1, D0, D1) \
do \
{ \
__m128i t0, t1; \
\
t0 = C0; C0 = C1; C1 = t0; \
t0 = B0; t1 = D0; \
B0 = _mm_unpackhi_epi64(B1, _mm_unpacklo_epi64(B0, B0)); \
B1 = _mm_unpackhi_epi64(t0, _mm_unpacklo_epi64(B1, B1)); \
D0 = _mm_unpackhi_epi64(D0, _mm_unpacklo_epi64(D1, D1)); \
D1 = _mm_unpackhi_epi64(D1, _mm_unpacklo_epi64(t1, t1)); \
} while(0)
#endif
#define F(S) \
do \
{ \
G(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7]); \
DIAGONALIZE(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7]); \
G(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7]); \
UNDIAGONALIZE(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7]); \
} while(0)
#define PERMUTE(S) \
do \
{ \
int i; \
for(i = 0; i < NORX_L; ++i) \
{ \
F(S); \
} \
} while(0)
#define INJECT_DOMAIN_CONSTANT(S, TAG) \
do \
{ \
S[7] = XOR(S[7], _mm_set_epi64x(TAG, 0)); \
} while(0)
#define INJECT_KEY(S, K0, K1) do { \
S[6] = XOR(S[6], K0); \
S[7] = XOR(S[7], K1); \
} while(0)
#define ABSORB_BLOCK(S, IN, TAG) \
do \
{ \
size_t j; \
INJECT_DOMAIN_CONSTANT(S, TAG); \
PERMUTE(S); \
for (j = 0; j < WORDS(NORX_R)/2; ++j) \
{ \
S[j] = XOR(S[j], LOADU(IN + j * 2 * BYTES(NORX_W))); \
} \
} while(0)
#define ABSORB_LASTBLOCK(S, IN, INLEN, TAG) \
do \
{ \
ALIGN(64) unsigned char lastblock[BYTES(NORX_R)]; \
PAD(lastblock, sizeof lastblock, IN, INLEN); \
ABSORB_BLOCK(S, lastblock, TAG); \
} while(0)
#define ENCRYPT_BLOCK(S, OUT, IN) \
do \
{ \
size_t j; \
INJECT_DOMAIN_CONSTANT(S, PAYLOAD_TAG); \
PERMUTE(S); \
for (j = 0; j < WORDS(NORX_R)/2; ++j) \
{ \
S[j] = XOR(S[j], LOADU(IN + j * 2 * BYTES(NORX_W))); \
STOREU(OUT + j * 2 * BYTES(NORX_W), S[j]); \
} \
} while(0)
#define ENCRYPT_LASTBLOCK(S, OUT, IN, INLEN) \
do \
{ \
ALIGN(64) unsigned char lastblock[BYTES(NORX_R)]; \
PAD(lastblock, sizeof lastblock, IN, INLEN); \
ENCRYPT_BLOCK(S, lastblock, lastblock); \
memcpy(OUT, lastblock, INLEN); \
} while(0)
#define DECRYPT_BLOCK(S, OUT, IN) \
do \
{ \
size_t j; \
INJECT_DOMAIN_CONSTANT(S, PAYLOAD_TAG); \
PERMUTE(S); \
for (j = 0; j < WORDS(NORX_R)/2; ++j) \
{ \
__m128i T = LOADU(IN + j * 2 * BYTES(NORX_W)); \
STOREU(OUT + j * 2 * BYTES(NORX_W), XOR(S[j], T)); \
S[j] = T; \
} \
} while(0)
#define DECRYPT_LASTBLOCK(S, OUT, IN, INLEN) \
do \
{ \
size_t j; \
ALIGN(64) unsigned char lastblock[BYTES(NORX_R)] = {0}; \
INJECT_DOMAIN_CONSTANT(S, PAYLOAD_TAG); \
PERMUTE(S); \
for (j = 0; j < WORDS(NORX_R)/2; ++j) \
{ \
STOREU(lastblock + j * 2 * BYTES(NORX_W), S[j]); \
} \
memcpy(lastblock, IN, INLEN); \
lastblock[INLEN] ^= 0x01; \
lastblock[BYTES(NORX_R) - 1] ^= 0x80; \
for (j = 0; j < WORDS(NORX_R)/2; ++j) \
{ \
__m128i T = LOADU(lastblock + j * 2 * BYTES(NORX_W)); \
STOREU(lastblock + j * 2 * BYTES(NORX_W), XOR(S[j], T)); \
S[j] = T; \
} \
memcpy(OUT, lastblock, INLEN); \
} while(0)
#define INITIALISE(S, NONCE, K0, K1) \
do \
{ \
S[0] = LOADU(NONCE + 0); \
S[1] = LOADU(NONCE + 16); \
S[2] = K0; \
S[3] = K1; \
S[4] = _mm_set_epi64x( U9, U8); \
S[5] = _mm_set_epi64x(U11, U10); \
S[6] = _mm_set_epi64x(U13, U12); \
S[7] = _mm_set_epi64x(U15, U14); \
S[6] = XOR(S[6], _mm_set_epi64x(NORX_L, NORX_W)); \
S[7] = XOR(S[7], _mm_set_epi64x(NORX_T, NORX_P)); \
PERMUTE(S); \
INJECT_KEY(S, K0, K1); \
} while(0)
#define ABSORB_DATA(S, IN, INLEN, TAG) \
do \
{ \
if (INLEN > 0) \
{ \
size_t i = 0; \
size_t l = INLEN; \
while (l >= BYTES(NORX_R)) \
{ \
ABSORB_BLOCK(S, IN + i, TAG); \
i += BYTES(NORX_R); \
l -= BYTES(NORX_R); \
} \
ABSORB_LASTBLOCK(S, IN + i, l, TAG); \
} \
} while(0)
#define ENCRYPT_DATA(S, OUT, IN, INLEN) \
do \
{ \
if (INLEN > 0) \
{ \
size_t i = 0; \
size_t l = INLEN; \
while (l >= BYTES(NORX_R)) \
{ \
ENCRYPT_BLOCK(S, OUT + i, IN + i); \
i += BYTES(NORX_R); \
l -= BYTES(NORX_R); \
} \
ENCRYPT_LASTBLOCK(S, OUT + i, IN + i, l); \
} \
} while(0)
#define DECRYPT_DATA(S, OUT, IN, INLEN) \
do \
{ \
if (INLEN > 0) \
{ \
size_t i = 0; \
size_t l = INLEN; \
while (l >= BYTES(NORX_R)) \
{ \
DECRYPT_BLOCK(S, OUT + i, IN + i); \
i += BYTES(NORX_R); \
l -= BYTES(NORX_R); \
} \
DECRYPT_LASTBLOCK(S, OUT + i, IN + i, l); \
} \
} while(0)
#define FINALISE(S, K0, K1) \
do \
{ \
INJECT_DOMAIN_CONSTANT(S, FINAL_TAG); \
PERMUTE(S); \
INJECT_KEY(S, K0, K1); \
PERMUTE(S); \
INJECT_KEY(S, K0, K1); \
} while(0)
#define PAD(OUT, OUTLEN, IN, INLEN) \
do \
{ \
memset(OUT, 0, OUTLEN); \
memcpy(OUT, IN, INLEN); \
OUT[INLEN] = 0x01; \
OUT[OUTLEN - 1] |= 0x80; \
} while(0)
typedef enum tag__
{
HEADER_TAG = 0x01,
PAYLOAD_TAG = 0x02,
TRAILER_TAG = 0x04,
FINAL_TAG = 0x08,
BRANCH_TAG = 0x10,
MERGE_TAG = 0x20
} tag_t;
void norx_aead_encrypt(
unsigned char *c, size_t *clen,
const unsigned char *a, size_t alen,
const unsigned char *m, size_t mlen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce,
const unsigned char *key
)
{
const __m128i K0 = LOADU(key + 0);
const __m128i K1 = LOADU(key + 16);
__m128i S[8];
*clen = mlen + BYTES(NORX_T);
INITIALISE(S, nonce, K0, K1);
ABSORB_DATA(S, a, alen, HEADER_TAG);
ENCRYPT_DATA(S, c, m, mlen);
ABSORB_DATA(S, z, zlen, TRAILER_TAG);
FINALISE(S, K0, K1);
STOREU(c + mlen, S[6]);
STOREU(c + mlen + BYTES(NORX_T)/2, S[7]);
}
int norx_aead_decrypt(
unsigned char *m, size_t *mlen,
const unsigned char *a, size_t alen,
const unsigned char *c, size_t clen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce,
const unsigned char *key
)
{
const __m128i K0 = LOADU(key + 0);
const __m128i K1 = LOADU(key + 16);
__m128i S[8];
if (clen < BYTES(NORX_T)) { return -1; }
*mlen = clen - BYTES(NORX_T);
INITIALISE(S, nonce, K0, K1);
ABSORB_DATA(S, a, alen, HEADER_TAG);
DECRYPT_DATA(S, m, c, clen - BYTES(NORX_T));
ABSORB_DATA(S, z, zlen, TRAILER_TAG);
FINALISE(S, K0, K1);
/* Verify tag */
S[6] = _mm_cmpeq_epi8(S[6], LOADU(c + clen - BYTES(NORX_T) ));
S[7] = _mm_cmpeq_epi8(S[7], LOADU(c + clen - BYTES(NORX_T)/2));
return (((_mm_movemask_epi8(AND(S[6], S[7])) & 0xFFFFUL) + 1) >> 16) - 1;
}
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
CFLAGS=-O3 -march=native -std=c89 -Wall -Wextra -pedantic -Wno-long-long
all: check bench
debug:
@$(CC) $(CFLAGS) -DNORX_DEBUG -I. -o debug ../../utils/debug.c norx.c
@./debug
@rm debug
bench:
@$(CC) $(CFLAGS) -o bench ../../utils/bench.c norx.c caesar.c
@./bench
@rm bench
check:
@$(CC) $(CFLAGS) -I../ -o check ../../utils/check.c norx.c caesar.c
@./check
@rm check
genkat:
$(CC) $(CFLAGS) -o genkat ../../utils/genkat.c norx.c caesar.c
./genkat > ../kat.h
rm genkat
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
* NORX reference source code package - reference C implementations
*
* Written 2014-2016 by:
*
* - Samuel Neves <[email protected]>
* - Philipp Jovanovic <[email protected]>
*
* To the extent possible under law, the author(s) have dedicated all copyright
* and related and neighboring rights to this software to the public domain
* worldwide. This software is distributed without any warranty.
*
* You should have received a copy of the CC0 Public Domain Dedication along with
* this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#define NORX_W 64 /* Word size */
#define NORX_L 4 /* Round number */
#define NORX_P 1 /* Parallelism degree */
#define NORX_T (NORX_W * 4) /* Tag size */
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
* NORX reference source code package - reference C implementations
*
* Written 2014-2016 by:
*
* - Samuel Neves <[email protected]>
* - Philipp Jovanovic <[email protected]>
*
* To the extent possible under law, the author(s) have dedicated all copyright
* and related and neighboring rights to this software to the public domain
* worldwide. This software is distributed without any warranty.
*
* You should have received a copy of the CC0 Public Domain Dedication along with
* this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#ifndef NORX_DEFS_H
#define NORX_DEFS_H
/* Workaround for C89 compilers */
#if !defined(__cplusplus) && (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L)
#if defined(_MSC_VER)
#define NORX_INLINE __inline
#elif defined(__GNUC__)
#define NORX_INLINE __inline__
#else
#define NORX_INLINE
#endif
#else
#define NORX_INLINE inline
#endif
#include <limits.h>
#include <stddef.h>
#include <string.h>
#include <stdint.h>
#define STR_(x) #x
#define STR(x) STR_(x)
#define PASTE_(A, B, C) A ## B ## C
#define PASTE(A, B, C) PASTE_(A, B, C)
#define BYTES(x) (((x) + 7) / 8)
#define WORDS(x) (((x) + (NORX_W-1)) / NORX_W)
#define BITS(x) (sizeof(x) * CHAR_BIT)
#define ROTL(x, c) ( ((x) << (c)) | ((x) >> (BITS(x) - (c))) )
#define ROTR(x, c) ( ((x) >> (c)) | ((x) << (BITS(x) - (c))) )
static NORX_INLINE uint32_t load32(const void * in)
{
#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
uint32_t v;
memcpy(&v, in, sizeof v);
return v;
#else
const uint8_t * p = (const uint8_t *)in;
return ((uint32_t)p[0] << 0) |
((uint32_t)p[1] << 8) |
((uint32_t)p[2] << 16) |
((uint32_t)p[3] << 24);
#endif
}
static NORX_INLINE uint64_t load64(const void * in)
{
#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
uint64_t v;
memcpy(&v, in, sizeof v);
return v;
#else
const uint8_t * p = (const uint8_t *)in;
return ((uint64_t)p[0] << 0) |
((uint64_t)p[1] << 8) |
((uint64_t)p[2] << 16) |
((uint64_t)p[3] << 24) |
((uint64_t)p[4] << 32) |
((uint64_t)p[5] << 40) |
((uint64_t)p[6] << 48) |
((uint64_t)p[7] << 56);
#endif
}
static NORX_INLINE void store32(void * out, const uint32_t v)
{
#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
memcpy(out, &v, sizeof v);
#else
uint8_t * p = (uint8_t *)out;
p[0] = (uint8_t)(v >> 0);
p[1] = (uint8_t)(v >> 8);
p[2] = (uint8_t)(v >> 16);
p[3] = (uint8_t)(v >> 24);
#endif
}
static NORX_INLINE void store64(void * out, const uint64_t v)
{
#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
memcpy(out, &v, sizeof v);
#else
uint8_t * p = (uint8_t *)out;
p[0] = (uint8_t)(v >> 0);
p[1] = (uint8_t)(v >> 8);
p[2] = (uint8_t)(v >> 16);
p[3] = (uint8_t)(v >> 24);
p[4] = (uint8_t)(v >> 32);
p[5] = (uint8_t)(v >> 40);
p[6] = (uint8_t)(v >> 48);
p[7] = (uint8_t)(v >> 56);
#endif
}
static void* (* const volatile burn)(void*, int, size_t) = memset;
#endif
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
* NORX reference source code package - reference C implementations
*
* Written 2014-2016 by:
*
* - Samuel Neves <[email protected]>
* - Philipp Jovanovic <[email protected]>
*
* To the extent possible under law, the author(s) have dedicated all copyright
* and related and neighboring rights to this software to the public domain
* worldwide. This software is distributed without any warranty.
*
* You should have received a copy of the CC0 Public Domain Dedication along with
* this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#define CRYPTO_KEYBYTES 32
#define CRYPTO_NSECBYTES 0
#define CRYPTO_NPUBBYTES 32
#define CRYPTO_ABYTES 32
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
* NORX reference source code package - reference C implementations
*
* Written 2014-2016 by:
*
* - Samuel Neves <[email protected]>
* - Philipp Jovanovic <[email protected]>
*
* To the extent possible under law, the author(s) have dedicated all copyright
* and related and neighboring rights to this software to the public domain
* worldwide. This software is distributed without any warranty.
*
* You should have received a copy of the CC0 Public Domain Dedication along with
* this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#if defined(SUPERCOP)
# include "crypto_aead.h"
#endif
#include "api.h"
#include "norx.h"
/*
the code for the cipher implementation goes here,
generating a ciphertext c[0],c[1],...,c[*clen-1]
from a plaintext m[0],m[1],...,m[mlen-1]
and associated data ad[0],ad[1],...,ad[adlen-1]
and secret message number nsec[0],nsec[1],...
and public message number npub[0],npub[1],...
and secret key k[0],k[1],...
*/
int crypto_aead_encrypt(
unsigned char *c, unsigned long long *clen,
const unsigned char *m, unsigned long long mlen,
const unsigned char *ad, unsigned long long adlen,
const unsigned char *nsec,
const unsigned char *npub,
const unsigned char *k
)
{
size_t outlen = 0;
norx_aead_encrypt(c, &outlen, ad, adlen, m, mlen, NULL, 0, npub, k);
*clen = outlen;
(void)nsec; /* avoid warning */
return 0;
}
/*
the code for the cipher implementation goes here,
generating a plaintext m[0],m[1],...,m[*mlen-1]
and secret message number nsec[0],nsec[1],...
from a ciphertext c[0],c[1],...,c[clen-1]
and associated data ad[0],ad[1],...,ad[adlen-1]
and public message number npub[0],npub[1],...
and secret key k[0],k[1],...
*/
int crypto_aead_decrypt(
unsigned char *m, unsigned long long *mlen,
unsigned char *nsec,
const unsigned char *c, unsigned long long clen,
const unsigned char *ad, unsigned long long adlen,
const unsigned char *npub,
const unsigned char *k
)
{
size_t outlen = 0;
int result = norx_aead_decrypt(m, &outlen, ad, adlen, c, clen, NULL, 0, npub, k);
*mlen = outlen;
(void)nsec; /* avoid warning */
return result;
}
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
* NORX reference source code package - reference C implementations
*
* Written 2014-2016 by:
*
* - Samuel Neves <[email protected]>
* - Philipp Jovanovic <[email protected]>
*
* To the extent possible under law, the author(s) have dedicated all copyright
* and related and neighboring rights to this software to the public domain
* worldwide. This software is distributed without any warranty.
*
* You should have received a copy of the CC0 Public Domain Dedication along with
* this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#ifndef NORX_NORX_H
#define NORX_NORX_H
#include <stddef.h>
#include <stdint.h>
#include "norx_config.h"
#if NORX_W == 64
typedef uint64_t norx_word_t;
#elif NORX_W == 32
typedef uint32_t norx_word_t;
#else
#error "Invalid word size!"
#endif
typedef struct norx_state__
{
norx_word_t S[16];
} norx_state_t[1];
typedef enum tag__
{
HEADER_TAG = 0x01,
PAYLOAD_TAG = 0x02,
TRAILER_TAG = 0x04,
FINAL_TAG = 0x08,
BRANCH_TAG = 0x10,
MERGE_TAG = 0x20
} tag_t;
/* High-level operations */
void norx_aead_encrypt(
unsigned char *c, size_t *clen,
const unsigned char *a, size_t alen,
const unsigned char *m, size_t mlen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce, const unsigned char *key);
int norx_aead_decrypt(
unsigned char *m, size_t *mlen,
const unsigned char *a, size_t alen,
const unsigned char *c, size_t clen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce, const unsigned char *key);
#endif
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
* NORX reference source code package - reference C implementations
*
* Written 2014-2016 by:
*
* - Samuel Neves <[email protected]>
* - Philipp Jovanovic <[email protected]>
*
* To the extent possible under law, the author(s) have dedicated all copyright
* and related and neighboring rights to this software to the public domain
* worldwide. This software is distributed without any warranty.
*
* You should have received a copy of the CC0 Public Domain Dedication along with
* this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "norx_util.h"
#include "norx.h"
const char * norx_version = "3.0";
#define NORX_N (NORX_W * 4) /* Nonce size */
#define NORX_K (NORX_W * 4) /* Key size */
#define NORX_B (NORX_W * 16) /* Permutation width */
#define NORX_C (NORX_W * 4) /* Capacity */
#define NORX_R (NORX_B - NORX_C) /* Rate */
#if NORX_W == 32 /* NORX32 specific */
#define LOAD load32
#define STORE store32
/* Rotation constants */
#define R0 8
#define R1 11
#define R2 16
#define R3 31
#elif NORX_W == 64 /* NORX64 specific */
#define LOAD load64
#define STORE store64
/* Rotation constants */
#define R0 8
#define R1 19
#define R2 40
#define R3 63
#else
#error "Invalid word size!"
#endif
#if defined(NORX_DEBUG)
#include <stdio.h>
#include <inttypes.h>
#if NORX_W == 32
#define NORX_FMT "08" PRIX32
#elif NORX_W == 64
#define NORX_FMT "016" PRIX64
#endif
static void norx_print_state(norx_state_t state)
{
static const char fmt[] = "%" NORX_FMT " "
"%" NORX_FMT " "
"%" NORX_FMT " "
"%" NORX_FMT "\n";
const norx_word_t * S = state->S;
printf(fmt, S[ 0],S[ 1],S[ 2],S[ 3]);
printf(fmt, S[ 4],S[ 5],S[ 6],S[ 7]);
printf(fmt, S[ 8],S[ 9],S[10],S[11]);
printf(fmt, S[12],S[13],S[14],S[15]);
printf("\n");
}
static void print_bytes(const uint8_t *in, size_t inlen)
{
size_t i;
for (i = 0; i < inlen; ++i) {
printf("%02X%c", in[i], i%16 == 15 ? '\n' : ' ');
}
if (inlen%16 != 0) {
printf("\n");
}
}
static void norx_debug(norx_state_t state, const uint8_t *in, size_t inlen, const uint8_t *out, size_t outlen)
{
if (in != NULL && inlen > 0) {
printf("In:\n");
print_bytes(in, inlen);
}
if (out != NULL && outlen > 0) {
printf("Out:\n");
print_bytes(out, outlen);
}
printf("State:\n");
norx_print_state(state);
}
#endif
/* The nonlinear primitive */
#define H(A, B) ( ( (A) ^ (B) ) ^ ( ( (A) & (B) ) << 1) )
/* The quarter-round */
#define G(A, B, C, D) \
do \
{ \
(A) = H(A, B); (D) ^= (A); (D) = ROTR((D), R0); \
(C) = H(C, D); (B) ^= (C); (B) = ROTR((B), R1); \
(A) = H(A, B); (D) ^= (A); (D) = ROTR((D), R2); \
(C) = H(C, D); (B) ^= (C); (B) = ROTR((B), R3); \
} while (0)
/* The full round */
static NORX_INLINE void F(norx_word_t S[16])
{
/* Column step */
G(S[ 0], S[ 4], S[ 8], S[12]);
G(S[ 1], S[ 5], S[ 9], S[13]);
G(S[ 2], S[ 6], S[10], S[14]);
G(S[ 3], S[ 7], S[11], S[15]);
/* Diagonal step */
G(S[ 0], S[ 5], S[10], S[15]);
G(S[ 1], S[ 6], S[11], S[12]);
G(S[ 2], S[ 7], S[ 8], S[13]);
G(S[ 3], S[ 4], S[ 9], S[14]);
}
/* The core permutation */
static NORX_INLINE void norx_permute(norx_state_t state)
{
size_t i;
norx_word_t * S = state->S;
for (i = 0; i < NORX_L; ++i) {
F(S);
}
}
static NORX_INLINE void norx_pad(uint8_t *out, const uint8_t *in, const size_t inlen)
{
memset(out, 0, BYTES(NORX_R));
memcpy(out, in, inlen);
out[inlen] = 0x01;
out[BYTES(NORX_R) - 1] |= 0x80;
}
static NORX_INLINE void norx_absorb_block(norx_state_t state, const uint8_t * in, tag_t tag)
{
size_t i;
norx_word_t * S = state->S;
S[15] ^= tag;
norx_permute(state);
for (i = 0; i < WORDS(NORX_R); ++i) {
S[i] ^= LOAD(in + i * BYTES(NORX_W));
}
}
static NORX_INLINE void norx_absorb_lastblock(norx_state_t state, const uint8_t * in, size_t inlen, tag_t tag)
{
uint8_t lastblock[BYTES(NORX_R)];
norx_pad(lastblock, in, inlen);
norx_absorb_block(state, lastblock, tag);
}
static NORX_INLINE void norx_encrypt_block(norx_state_t state, uint8_t *out, const uint8_t * in)
{
size_t i;
norx_word_t * S = state->S;
S[15] ^= PAYLOAD_TAG;
norx_permute(state);
for (i = 0; i < WORDS(NORX_R); ++i) {
S[i] ^= LOAD(in + i * BYTES(NORX_W));
STORE(out + i * BYTES(NORX_W), S[i]);
}
}
static NORX_INLINE void norx_encrypt_lastblock(norx_state_t state, uint8_t *out, const uint8_t * in, size_t inlen)
{
uint8_t lastblock[BYTES(NORX_R)];
norx_pad(lastblock, in, inlen);
norx_encrypt_block(state, lastblock, lastblock);
memcpy(out, lastblock, inlen);
}
static NORX_INLINE void norx_decrypt_block(norx_state_t state, uint8_t *out, const uint8_t * in)
{
size_t i;
norx_word_t * S = state->S;
S[15] ^= PAYLOAD_TAG;
norx_permute(state);
for (i = 0; i < WORDS(NORX_R); ++i) {
const norx_word_t c = LOAD(in + i * BYTES(NORX_W));
STORE(out + i * BYTES(NORX_W), S[i] ^ c);
S[i] = c;
}
}
static NORX_INLINE void norx_decrypt_lastblock(norx_state_t state, uint8_t *out, const uint8_t * in, size_t inlen)
{
norx_word_t * S = state->S;
uint8_t lastblock[BYTES(NORX_R)];
size_t i;
S[15] ^= PAYLOAD_TAG;
norx_permute(state);
for(i = 0; i < WORDS(NORX_R); ++i) {
STORE(lastblock + i * BYTES(NORX_W), S[i]);
}
memcpy(lastblock, in, inlen);
lastblock[inlen] ^= 0x01;
lastblock[BYTES(NORX_R) - 1] ^= 0x80;
for (i = 0; i < WORDS(NORX_R); ++i) {
const norx_word_t c = LOAD(lastblock + i * BYTES(NORX_W));
STORE(lastblock + i * BYTES(NORX_W), S[i] ^ c);
S[i] = c;
}
memcpy(out, lastblock, inlen);
burn(lastblock, 0, sizeof lastblock);
}
/* Low-level operations */
static NORX_INLINE void norx_init(norx_state_t state, const unsigned char *k, const unsigned char *n)
{
norx_word_t * S = state->S;
size_t i;
for(i = 0; i < 16; ++i) {
S[i] = i;
}
F(S);
F(S);
S[ 0] = LOAD(n + 0 * BYTES(NORX_W));
S[ 1] = LOAD(n + 1 * BYTES(NORX_W));
S[ 2] = LOAD(n + 2 * BYTES(NORX_W));
S[ 3] = LOAD(n + 3 * BYTES(NORX_W));
S[ 4] = LOAD(k + 0 * BYTES(NORX_W));
S[ 5] = LOAD(k + 1 * BYTES(NORX_W));
S[ 6] = LOAD(k + 2 * BYTES(NORX_W));
S[ 7] = LOAD(k + 3 * BYTES(NORX_W));
S[12] ^= NORX_W;
S[13] ^= NORX_L;
S[14] ^= NORX_P;
S[15] ^= NORX_T;
norx_permute(state);
S[12] ^= LOAD(k + 0 * BYTES(NORX_W));
S[13] ^= LOAD(k + 1 * BYTES(NORX_W));
S[14] ^= LOAD(k + 2 * BYTES(NORX_W));
S[15] ^= LOAD(k + 3 * BYTES(NORX_W));
#if defined(NORX_DEBUG)
printf("Initialise\n");
norx_debug(state, NULL, 0, NULL, 0);
#endif
}
void norx_absorb_data(norx_state_t state, const unsigned char * in, size_t inlen, tag_t tag)
{
if (inlen > 0)
{
while (inlen >= BYTES(NORX_R))
{
norx_absorb_block(state, in, tag);
#if defined(NORX_DEBUG)
printf("Absorb block\n");
norx_debug(state, in, BYTES(NORX_R), NULL, 0);
#endif
inlen -= BYTES(NORX_R);
in += BYTES(NORX_R);
}
norx_absorb_lastblock(state, in, inlen, tag);
#if defined(NORX_DEBUG)
printf("Absorb lastblock\n");
norx_debug(state, in, inlen, NULL, 0);
#endif
}
}
#if NORX_P != 1 /* only required in parallel modes */
static NORX_INLINE void norx_branch(norx_state_t state, uint64_t lane)
{
size_t i;
norx_word_t * S = state->S;
S[15] ^= BRANCH_TAG;
norx_permute(state);
/* Inject lane ID */
for (i = 0; i < WORDS(NORX_R); ++i) {
S[i] ^= lane;
}
}
/* state = state xor state1 */
static NORX_INLINE void norx_merge(norx_state_t state, norx_state_t state1)
{
size_t i;
norx_word_t * S = state->S;
norx_word_t * S1 = state1->S;
S1[15] ^= MERGE_TAG;
norx_permute(state1);
for (i = 0; i < 16; ++i) {
S[i] ^= S1[i];
}
}
#endif
#if NORX_P == 1 /* Sequential encryption/decryption */
void norx_encrypt_data(norx_state_t state, unsigned char *out, const unsigned char * in, size_t inlen)
{
if (inlen > 0)
{
while (inlen >= BYTES(NORX_R))
{
norx_encrypt_block(state, out, in);
#if defined(NORX_DEBUG)
printf("Encrypt block\n");
norx_debug(state, in, BYTES(NORX_R), out, BYTES(NORX_R));
#endif
inlen -= BYTES(NORX_R);
in += BYTES(NORX_R);
out += BYTES(NORX_R);
}
norx_encrypt_lastblock(state, out, in, inlen);
#if defined(NORX_DEBUG)
printf("Encrypt lastblock\n");
norx_debug(state, in, inlen, out, inlen);
#endif
}
}
void norx_decrypt_data(norx_state_t state, unsigned char *out, const unsigned char * in, size_t inlen)
{
if (inlen > 0)
{
while (inlen >= BYTES(NORX_R))
{
norx_decrypt_block(state, out, in);
#if defined(NORX_DEBUG)
printf("Decrypt block\n");
norx_debug(state, in, BYTES(NORX_R), out, BYTES(NORX_R));
#endif
inlen -= BYTES(NORX_R);
in += BYTES(NORX_R);
out += BYTES(NORX_R);
}
norx_decrypt_lastblock(state, out, in, inlen);
#if defined(NORX_DEBUG)
printf("Decrypt lastblock\n");
norx_debug(state, in, inlen, out, inlen);
#endif
}
}
#elif NORX_P > 1 /* Parallel encryption/decryption */
void norx_encrypt_data(norx_state_t state, unsigned char *out, const unsigned char * in, size_t inlen)
{
if (inlen > 0)
{
size_t i;
norx_state_t lane[NORX_P];
/* Initialize states + branch */
for (i = 0; i < NORX_P; ++i) {
memcpy(lane[i], state, sizeof lane[i]);
norx_branch(lane[i], i);
}
/* Parallel payload processing */
for (i = 0; inlen >= BYTES(NORX_R); ++i) {
norx_encrypt_block(lane[i%NORX_P], out, in);
#if defined(NORX_DEBUG)
printf("Encrypt block (lane: %lu)\n", i%NORX_P);
norx_debug(lane[i%NORX_P], in, BYTES(NORX_R), out, BYTES(NORX_R));
#endif
inlen -= BYTES(NORX_R);
out += BYTES(NORX_R);
in += BYTES(NORX_R);
}
norx_encrypt_lastblock(lane[i%NORX_P], out, in, inlen);
#if defined(NORX_DEBUG)
printf("Encrypt lastblock (lane: %lu)\n", i%NORX_P);
norx_debug(lane[i%NORX_P], in, inlen, out, inlen);
#endif
/* Merge */
memset(state, 0, sizeof(norx_state_t));
for (i = 0; i < NORX_P; ++i) {
norx_merge(state, lane[i]);
burn(lane[i], 0, sizeof(norx_state_t));
}
#if defined(NORX_DEBUG)
printf("Encryption finalised\n");
norx_debug(state, NULL, 0, NULL, 0);
#endif
}
}
void norx_decrypt_data(norx_state_t state, unsigned char *out, const unsigned char * in, size_t inlen)
{
if (inlen > 0)
{
size_t i;
norx_state_t lane[NORX_P];
/* Initialize states + branch */
for (i = 0; i < NORX_P; ++i) {
memcpy(lane[i], state, sizeof lane[i]);
norx_branch(lane[i], i);
}
/* Parallel payload processing */
for (i = 0; inlen >= BYTES(NORX_R); ++i) {
norx_decrypt_block(lane[i%NORX_P], out, in);
#if defined(NORX_DEBUG)
printf("Decrypt block (lane: %lu)\n", i%NORX_P);
norx_debug(lane[i%NORX_P], in, BYTES(NORX_R), out, BYTES(NORX_R));
#endif
inlen -= BYTES(NORX_R);
out += BYTES(NORX_R);
in += BYTES(NORX_R);
}
norx_decrypt_lastblock(lane[i%NORX_P], out, in, inlen);
#if defined(NORX_DEBUG)
printf("Decrypt lastblock (lane: %lu)\n", i%NORX_P);
norx_debug(lane[i%NORX_P], in, inlen, out, inlen);
#endif
/* Merge */
memset(state, 0, sizeof(norx_state_t));
for (i = 0; i < NORX_P; ++i) {
norx_merge(state, lane[i]);
burn(lane[i], 0, sizeof(norx_state_t));
}
#if defined(NORX_DEBUG)
printf("Decryption finalised\n");
norx_debug(state, NULL, 0, NULL, 0);
#endif
}
}
#elif NORX_P == 0 /* Unlimited parallelism */
void norx_encrypt_data(norx_state_t state, unsigned char *out, const unsigned char * in, size_t inlen)
{
if (inlen > 0)
{
size_t lane = 0;
norx_state_t sum;
norx_state_t state2;
memset(sum, 0, sizeof(norx_state_t));
while (inlen >= BYTES(NORX_R))
{
/* branch */
memcpy(state2, state, sizeof(norx_state_t));
norx_branch(state2, lane++);
/* encrypt */
norx_encrypt_block(state2, out, in);
#if defined(NORX_DEBUG)
printf("Encrypt block (lane: %lu)\n", lane - 1);
norx_debug(state2, in, BYTES(NORX_R), out, BYTES(NORX_R));
#endif
/* merge */
norx_merge(sum, state2);
inlen -= BYTES(NORX_R);
in += BYTES(NORX_R);
out += BYTES(NORX_R);
}
/* last block, 0 <= inlen < BYTES(NORX_R) */
/* branch */
memcpy(state2, state, sizeof(norx_state_t));
norx_branch(state2, lane++);
/* encrypt */
norx_encrypt_lastblock(state2, out, in, inlen);
#if defined(NORX_DEBUG)
printf("Encrypt lastblock (lane: %lu)\n", lane - 1);
norx_debug(state2, in, inlen, out, inlen);
#endif
/* merge */
norx_merge(sum, state2);
memcpy(state, sum, sizeof(norx_state_t));
burn(state2, 0, sizeof(norx_state_t));
burn(sum, 0, sizeof(norx_state_t));
#if defined(NORX_DEBUG)
printf("Encryption finalised\n");
norx_debug(state, NULL, 0, NULL, 0);
#endif
}
}
void norx_decrypt_data(norx_state_t state, unsigned char *out, const unsigned char * in, size_t inlen)
{
if (inlen > 0)
{
size_t lane = 0;
norx_state_t sum;
norx_state_t state2;
memset(sum, 0, sizeof(norx_state_t));
while (inlen >= BYTES(NORX_R))
{
/* branch */
memcpy(state2, state, sizeof(norx_state_t));
norx_branch(state2, lane++);
/* decrypt */
norx_decrypt_block(state2, out, in);
#if defined(NORX_DEBUG)
printf("Decrypt block (lane: %lu)\n", lane - 1);
norx_debug(state2, in, BYTES(NORX_R), out, BYTES(NORX_R));
#endif
/* merge */
norx_merge(sum, state2);
inlen -= BYTES(NORX_R);
in += BYTES(NORX_R);
out += BYTES(NORX_R);
}
/* last block, 0 <= inlen < BYTES(NORX_R) */
/* branch */
memcpy(state2, state, sizeof(norx_state_t));
norx_branch(state2, lane++);
/* decrypt */
norx_decrypt_lastblock(state2, out, in, inlen);
#if defined(NORX_DEBUG)
printf("Decrypt lastblock (lane: %lu)\n", lane - 1);
norx_debug(state2, in, inlen, out, inlen);
#endif
/* merge */
norx_merge(sum, state2);
memcpy(state, sum, sizeof(norx_state_t));
burn(state2, 0, sizeof(norx_state_t));
burn(sum, 0, sizeof(norx_state_t));
#if defined(NORX_DEBUG)
printf("Decryption finalised\n");
norx_debug(state, NULL, 0, NULL, 0);
#endif
}
}
#else /* D < 0 */
#error "NORX_P cannot be < 0"
#endif
static NORX_INLINE void norx_finalise(norx_state_t state, unsigned char * tag, const unsigned char * k)
{
norx_word_t * S = state->S;
uint8_t lastblock[BYTES(NORX_C)];
S[15] ^= FINAL_TAG;
norx_permute(state);
S[12] ^= LOAD(k + 0 * BYTES(NORX_W));
S[13] ^= LOAD(k + 1 * BYTES(NORX_W));
S[14] ^= LOAD(k + 2 * BYTES(NORX_W));
S[15] ^= LOAD(k + 3 * BYTES(NORX_W));
norx_permute(state);
S[12] ^= LOAD(k + 0 * BYTES(NORX_W));
S[13] ^= LOAD(k + 1 * BYTES(NORX_W));
S[14] ^= LOAD(k + 2 * BYTES(NORX_W));
S[15] ^= LOAD(k + 3 * BYTES(NORX_W));
STORE(lastblock + 0 * BYTES(NORX_W), S[12]);
STORE(lastblock + 1 * BYTES(NORX_W), S[13]);
STORE(lastblock + 2 * BYTES(NORX_W), S[14]);
STORE(lastblock + 3 * BYTES(NORX_W), S[15]);
memcpy(tag, lastblock, BYTES(NORX_T));
#if defined(NORX_DEBUG)
printf("Finalise\n");
norx_debug(state, NULL, 0, NULL, 0);
#endif
burn(lastblock, 0, BYTES(NORX_C)); /* burn buffer */
burn(state, 0, sizeof(norx_state_t)); /* at this point we can also burn the state */
}
/* Verify tags in constant time: 0 for success, -1 for fail */
int norx_verify_tag(const unsigned char * tag1, const unsigned char * tag2)
{
size_t i;
unsigned acc = 0;
for (i = 0; i < BYTES(NORX_T); ++i) {
acc |= tag1[i] ^ tag2[i];
}
return (((acc - 1) >> 8) & 1) - 1;
}
/* High-level operations */
void norx_aead_encrypt(
unsigned char *c, size_t *clen,
const unsigned char *a, size_t alen,
const unsigned char *m, size_t mlen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce,
const unsigned char *key
)
{
unsigned char k[BYTES(NORX_K)];
norx_state_t state;
memcpy(k, key, sizeof(k));
norx_init(state, k, nonce);
norx_absorb_data(state, a, alen, HEADER_TAG);
norx_encrypt_data(state, c, m, mlen);
norx_absorb_data(state, z, zlen, TRAILER_TAG);
norx_finalise(state, c + mlen, k);
*clen = mlen + BYTES(NORX_T);
burn(state, 0, sizeof(norx_state_t));
burn(k, 0, sizeof(k));
}
int norx_aead_decrypt(
unsigned char *m, size_t *mlen,
const unsigned char *a, size_t alen,
const unsigned char *c, size_t clen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce,
const unsigned char *key
)
{
unsigned char k[BYTES(NORX_K)];
unsigned char tag[BYTES(NORX_T)];
norx_state_t state;
int result = -1;
if (clen < BYTES(NORX_T)) {
return -1;
}
memcpy(k, key, sizeof(k));
norx_init(state, k, nonce);
norx_absorb_data(state, a, alen, HEADER_TAG);
norx_decrypt_data(state, m, c, clen - BYTES(NORX_T));
norx_absorb_data(state, z, zlen, TRAILER_TAG);
norx_finalise(state, tag, k);
*mlen = clen - BYTES(NORX_T);
result = norx_verify_tag(c + clen - BYTES(NORX_T), tag);
if (result != 0) { /* burn decrypted plaintext on auth failure */
burn(m, 0, clen - BYTES(NORX_T));
}
burn(state, 0, sizeof(norx_state_t));
burn(k, 0, sizeof(k));
return result;
}
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
CFLAGS=-O3 -mcpu=cortex-a8 -mfpu=neon -std=gnu99 -Wall -pedantic -Wno-long-long
all: check bench
debug:
@$(CC) $(CFLAGS) -DNORX_DEBUG -I. -o debug ../../utils/debug.c norx.c
@./debug
@rm debug
bench:
@$(CC) $(CFLAGS) -o bench ../../utils/bench.c norx.c caesar.c
@./bench
@rm bench
check:
@$(CC) $(CFLAGS) -I../ -o check ../../utils/check.c norx.c caesar.c
@./check
@rm check
.PHONY: check debug bench
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
NORX reference source code package - reference C implementations
Written 2014-2015 by:
- Samuel Neves <[email protected]>
- Philipp Jovanovic <[email protected]>
To the extent possible under law, the author(s) have dedicated all copyright
and related and neighboring rights to this software to the public domain
worldwide. This software is distributed without any warranty.
You should have received a copy of the CC0 Public Domain Dedication along with
this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#define CRYPTO_KEYBYTES 32
#define CRYPTO_NSECBYTES 0
#define CRYPTO_NPUBBYTES 32
#define CRYPTO_ABYTES 32
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
NORX reference source code package - reference C implementations
Written 2014-2015 by:
- Samuel Neves <[email protected]>
- Philipp Jovanovic <[email protected]>
To the extent possible under law, the author(s) have dedicated all copyright
and related and neighboring rights to this software to the public domain
worldwide. This software is distributed without any warranty.
You should have received a copy of the CC0 Public Domain Dedication along with
this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#if defined(SUPERCOP)
# include "crypto_aead.h"
#endif
#include "api.h"
#include "norx.h"
/*
the code for the cipher implementation goes here,
generating a ciphertext c[0],c[1],...,c[*clen-1]
from a plaintext m[0],m[1],...,m[mlen-1]
and associated data ad[0],ad[1],...,ad[adlen-1]
and secret message number nsec[0],nsec[1],...
and public message number npub[0],npub[1],...
and secret key k[0],k[1],...
*/
int crypto_aead_encrypt(
unsigned char *c, unsigned long long *clen,
const unsigned char *m, unsigned long long mlen,
const unsigned char *ad, unsigned long long adlen,
const unsigned char *nsec,
const unsigned char *npub,
const unsigned char *k
)
{
size_t outlen = 0;
norx_aead_encrypt(c, &outlen, ad, adlen, m, mlen, NULL, 0, npub, k);
*clen = outlen;
(void)nsec; /* avoid warning */
return 0;
}
/*
the code for the cipher implementation goes here,
generating a plaintext m[0],m[1],...,m[*mlen-1]
and secret message number nsec[0],nsec[1],...
from a ciphertext c[0],c[1],...,c[clen-1]
and associated data ad[0],ad[1],...,ad[adlen-1]
and public message number npub[0],npub[1],...
and secret key k[0],k[1],...
*/
int crypto_aead_decrypt(
unsigned char *m, unsigned long long *mlen,
unsigned char *nsec,
const unsigned char *c, unsigned long long clen,
const unsigned char *ad, unsigned long long adlen,
const unsigned char *npub,
const unsigned char *k
)
{
size_t outlen = 0;
int result = norx_aead_decrypt(m, &outlen, ad, adlen, c, clen, NULL, 0, npub, k);
*mlen = outlen;
(void)nsec; /* avoid warning */
return result;
}
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
NORX reference source code package - reference C implementations
Written 2014-2015 by:
- Samuel Neves <[email protected]>
- Philipp Jovanovic <[email protected]>
To the extent possible under law, the author(s) have dedicated all copyright
and related and neighboring rights to this software to the public domain
worldwide. This software is distributed without any warranty.
You should have received a copy of the CC0 Public Domain Dedication along with
this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#ifndef NORX_NORX_H
#define NORX_NORX_H
#include <stddef.h>
#include <stdint.h>
/* High-level operations */
void norx_aead_encrypt(
unsigned char *c, size_t *clen,
const unsigned char *a, size_t alen,
const unsigned char *m, size_t mlen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce, const unsigned char *key);
int norx_aead_decrypt(
unsigned char *m, size_t *mlen,
const unsigned char *a, size_t alen,
const unsigned char *c, size_t clen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce, const unsigned char *key);
#endif
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
NORX reference source code package - reference C implementations
Written 2014-2015 by:
- Samuel Neves <[email protected]>
- Philipp Jovanovic <[email protected]>
To the extent possible under law, the author(s) have dedicated all copyright
and related and neighboring rights to this software to the public domain
worldwide. This software is distributed without any warranty.
You should have received a copy of the CC0 Public Domain Dedication along with
this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#include <stdint.h>
#include <string.h>
#include <arm_neon.h>
#include "norx.h"
const char * norx_version = "3.0";
#define NORX_W 64 /* word size */
#define NORX_L 4 /* round number */
#define NORX_P 1 /* parallelism degree */
#define NORX_T (NORX_W * 4) /* tag size */
#define NORX_N (NORX_W * 4) /* nonce size */
#define NORX_K (NORX_W * 4) /* key size */
#define NORX_B (NORX_W * 16) /* permutation width */
#define NORX_C (NORX_W * 4) /* capacity */
#define NORX_R (NORX_B - NORX_C) /* rate */
#define BYTES(x) (((x) + 7) / 8)
#define WORDS(x) (((x) + (NORX_W-1)) / NORX_W)
#define ALIGN(x) __attribute__((aligned(x)))
#define U32TOU64(X) vreinterpretq_u64_u32(X)
#define U64TOU32(X) vreinterpretq_u32_u64(X)
#define U8TOU32(X) vreinterpretq_u32_u8(X)
#define U32TOU8(X) vreinterpretq_u8_u32(X)
#define U8TOU64(X) vreinterpretq_u64_u8(X)
#define U64TOU8(X) vreinterpretq_u8_u64(X)
#define LOAD(in) U8TOU64( vld1q_u8((uint8_t *)(in)) )
#define STORE(out, x) vst1q_u8((uint8_t*)(out), U64TOU8(x))
#define LOADU(in) LOAD(in)
#define STOREU(out, x) STORE(out, x)
#define XOR(A, B) veorq_u64((A), (B))
#define AND(A, B) vandq_u64((A), (B))
#define ADD(A, B) vaddq_u64((A), (B))
#if 0
#define SHL(A) vshlq_n_u64((A), 1)
#else
#define SHL(A) ADD((A), (A))
#endif
#if 0
#define ROT_63(X) vsriq_n_u64(SHL(X), (X), 63)
#else
#define ROT_63(X) veorq_u64(SHL(X), vshrq_n_u64(X, 63))
#endif
#if 1
#define ROT_N(X, C) vsriq_n_u64(vshlq_n_u64((X), 64-(C)), (X), (C))
#else
#define ROT_N(X, C) veorq_u64(vshrq_n_u64((X), (C)), vshlq_n_u64(X, 64-(C)))
#endif
#define ROT(X, C) \
( \
(C) == 63 ? ROT_63(X) \
: /* else */ ROT_N(X, C) \
)
#define U0 0xE4D324772B91DF79ULL
#define U1 0x3AEC9ABAAEB02CCBULL
#define U2 0x9DFBA13DB4289311ULL
#define U3 0xEF9EB4BF5A97F2C8ULL
#define U4 0x3F466E92C1532034ULL
#define U5 0xE6E986626CC405C1ULL
#define U6 0xACE40F3B549184E1ULL
#define U7 0xD9CFD35762614477ULL
#define U8 0xB15E641748DE5E6BULL
#define U9 0xAA95E955E10F8410ULL
#define U10 0x28D1034441A9DD40ULL
#define U11 0x7F31BBF964E93BF5ULL
#define U12 0xB5E9E22493DFFB96ULL
#define U13 0xB980C852479FAFBDULL
#define U14 0xDA24516BF55EAFD4ULL
#define U15 0x86026AE8536F1501ULL
#define R0 8
#define R1 19
#define R2 40
#define R3 63
/* Implementation */
#define G(A0, A1, B0, B1, C0, C1, D0, D1) \
do \
{ \
uint64x2_t l0, l1, r0, r1; \
\
l0 = XOR(A0, B0); r0 = XOR(A1, B1); \
l1 = AND(A0, B0); r1 = AND(A1, B1); \
l1 = ADD(l1, l1); r1 = ADD(r1, r1); \
A0 = XOR(l0, l1); A1 = XOR(r0, r1); \
D0 = XOR(D0, A0); D1 = XOR(D1, A1); \
D0 = ROT(D0, R0); D1 = ROT(D1, R0); \
\
l0 = XOR(C0, D0); r0 = XOR(C1, D1); \
l1 = AND(C0, D0); r1 = AND(C1, D1); \
l1 = ADD(l1, l1); r1 = ADD(r1, r1); \
C0 = XOR(l0, l1); C1 = XOR(r0, r1); \
B0 = XOR(B0, C0); B1 = XOR(B1, C1); \
B0 = ROT(B0, R1); B1 = ROT(B1, R1); \
\
l0 = XOR(A0, B0); r0 = XOR(A1, B1); \
l1 = AND(A0, B0); r1 = AND(A1, B1); \
l1 = ADD(l1, l1); r1 = ADD(r1, r1); \
A0 = XOR(l0, l1); A1 = XOR(r0, r1); \
D0 = XOR(D0, A0); D1 = XOR(D1, A1); \
D0 = ROT(D0, R2); D1 = ROT(D1, R2); \
\
l0 = XOR(C0, D0); r0 = XOR(C1, D1); \
l1 = AND(C0, D0); r1 = AND(C1, D1); \
l1 = ADD(l1, l1); r1 = ADD(r1, r1); \
C0 = XOR(l0, l1); C1 = XOR(r0, r1); \
B0 = XOR(B0, C0); B1 = XOR(B1, C1); \
B0 = ROT(B0, R3); B1 = ROT(B1, R3); \
} while(0)
#define DIAGONALIZE(A0, A1, B0, B1, C0, C1, D0, D1) \
do \
{ \
uint64x2_t t0, t1; \
\
t0 = vcombine_u64( vget_high_u64(B0), vget_low_u64(B1) ); \
t1 = vcombine_u64( vget_high_u64(B1), vget_low_u64(B0) ); \
B0 = t0; \
B1 = t1; \
\
t0 = C0; \
C0 = C1; \
C1 = t0; \
\
t0 = vcombine_u64( vget_high_u64(D0), vget_low_u64(D1) ); \
t1 = vcombine_u64( vget_high_u64(D1), vget_low_u64(D0) ); \
D0 = t1; \
D1 = t0; \
} while(0)
#define UNDIAGONALIZE(A0, A1, B0, B1, C0, C1, D0, D1) \
do \
{ \
uint64x2_t t0, t1; \
\
t0 = vcombine_u64( vget_high_u64(B1), vget_low_u64(B0) ); \
t1 = vcombine_u64( vget_high_u64(B0), vget_low_u64(B1) ); \
B0 = t0; \
B1 = t1; \
\
t0 = C0; \
C0 = C1; \
C1 = t0; \
\
t0 = vcombine_u64( vget_high_u64(D1), vget_low_u64(D0) ); \
t1 = vcombine_u64( vget_high_u64(D0), vget_low_u64(D1) ); \
D0 = t1; \
D1 = t0; \
} while(0)
#define F(S) \
do \
{ \
G(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7]); \
DIAGONALIZE(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7]); \
G(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7]); \
UNDIAGONALIZE(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7]); \
} while(0)
#define PERMUTE(S) \
do \
{ \
int i; \
for(i = 0; i < NORX_L; ++i) \
{ \
F(S); \
} \
} while(0)
#define INJECT_DOMAIN_CONSTANT(S, TAG) \
do \
{ \
S[7] = XOR(S[7], vcombine_u64(vcreate_u64(0), vcreate_u64(TAG))); \
} while(0)
#define INJECT_KEY(S, K0, K1) do { \
S[6] = XOR(S[6], K0); \
S[7] = XOR(S[7], K1); \
} while(0)
#define ABSORB_BLOCK(S, IN, TAG) \
do \
{ \
size_t j; \
INJECT_DOMAIN_CONSTANT(S, TAG); \
PERMUTE(S); \
for (j = 0; j < WORDS(NORX_R)/2; ++j) \
{ \
S[j] = XOR(S[j], LOADU(IN + j * 2 * BYTES(NORX_W))); \
} \
} while(0)
#define ABSORB_LASTBLOCK(S, IN, INLEN, TAG) \
do \
{ \
ALIGN(32) unsigned char lastblock[BYTES(NORX_R)]; \
PAD(lastblock, sizeof lastblock, IN, INLEN); \
ABSORB_BLOCK(S, lastblock, TAG); \
} while(0)
#define ENCRYPT_BLOCK(S, OUT, IN) \
do \
{ \
size_t j; \
INJECT_DOMAIN_CONSTANT(S, PAYLOAD_TAG); \
PERMUTE(S); \
for (j = 0; j < WORDS(NORX_R)/2; ++j) \
{ \
S[j] = XOR(S[j], LOADU(IN + j * 2 * BYTES(NORX_W))); \
STOREU(OUT + j * 2 * BYTES(NORX_W), S[j]); \
} \
} while(0)
#define ENCRYPT_LASTBLOCK(S, OUT, IN, INLEN) \
do \
{ \
ALIGN(32) unsigned char lastblock[BYTES(NORX_R)]; \
PAD(lastblock, sizeof lastblock, IN, INLEN); \
ENCRYPT_BLOCK(S, lastblock, lastblock); \
memcpy(OUT, lastblock, INLEN); \
} while(0)
#define DECRYPT_BLOCK(S, OUT, IN) \
do \
{ \
size_t j; \
INJECT_DOMAIN_CONSTANT(S, PAYLOAD_TAG); \
PERMUTE(S); \
for (j = 0; j < WORDS(NORX_R)/2; ++j) \
{ \
uint64x2_t T = LOADU(IN + j * 2 * BYTES(NORX_W)); \
STOREU(OUT + j * 2 * BYTES(NORX_W), XOR(S[j], T)); \
S[j] = T; \
} \
} while(0)
#define DECRYPT_LASTBLOCK(S, OUT, IN, INLEN) \
do \
{ \
size_t j; \
ALIGN(32) unsigned char lastblock[BYTES(NORX_R)]; \
INJECT_DOMAIN_CONSTANT(S, PAYLOAD_TAG); \
PERMUTE(S); \
for (j = 0; j < WORDS(NORX_R)/2; ++j) \
{ \
STOREU(lastblock + j * 2 * BYTES(NORX_W), S[j]); \
} \
memcpy(lastblock, IN, INLEN); \
lastblock[INLEN] ^= 0x01; \
lastblock[BYTES(NORX_R) - 1] ^= 0x80; \
for (j = 0; j < WORDS(NORX_R)/2; ++j) \
{ \
uint64x2_t T = LOADU(lastblock + j * 2 * BYTES(NORX_W)); \
STOREU(lastblock + j * 2 * BYTES(NORX_W), XOR(S[j], T)); \
S[j] = T; \
} \
memcpy(OUT, lastblock, INLEN); \
} while(0)
#define INITIALISE(S, NONCE, K0, K1) do { \
S[0] = LOADU(NONCE + 0); \
S[1] = LOADU(NONCE + 16); \
S[2] = K0; \
S[3] = K1; \
S[4] = vcombine_u64( vcreate_u64( U8), vcreate_u64( U9) ); \
S[5] = vcombine_u64( vcreate_u64(U10), vcreate_u64(U11) ); \
S[6] = vcombine_u64( vcreate_u64(U12), vcreate_u64(U13) ); \
S[7] = vcombine_u64( vcreate_u64(U14), vcreate_u64(U15) ); \
S[6] = XOR(S[6], vcombine_u64( vcreate_u64(NORX_W), vcreate_u64(NORX_L) )); \
S[7] = XOR(S[7], vcombine_u64( vcreate_u64(NORX_P), vcreate_u64(NORX_T) )); \
PERMUTE(S); \
INJECT_KEY(S, K0, K1); \
} while(0)
#define ABSORB_DATA(S, IN, INLEN, TAG) \
do \
{ \
if (INLEN > 0) \
{ \
size_t i = 0; \
size_t l = INLEN; \
while (l >= BYTES(NORX_R)) \
{ \
ABSORB_BLOCK(S, IN + i, TAG); \
i += BYTES(NORX_R); \
l -= BYTES(NORX_R); \
} \
ABSORB_LASTBLOCK(S, IN + i, l, TAG); \
} \
} while(0)
#define ENCRYPT_DATA(S, OUT, IN, INLEN) \
do \
{ \
if (INLEN > 0) \
{ \
size_t i = 0; \
size_t l = INLEN; \
while (l >= BYTES(NORX_R)) \
{ \
ENCRYPT_BLOCK(S, OUT + i, IN + i); \
i += BYTES(NORX_R); \
l -= BYTES(NORX_R); \
} \
ENCRYPT_LASTBLOCK(S, OUT + i, IN + i, l); \
} \
} while(0)
#define DECRYPT_DATA(S, OUT, IN, INLEN) \
do \
{ \
if (INLEN > 0) \
{ \
size_t i = 0; \
size_t l = INLEN; \
while (l >= BYTES(NORX_R)) \
{ \
DECRYPT_BLOCK(S, OUT + i, IN + i); \
i += BYTES(NORX_R); \
l -= BYTES(NORX_R); \
} \
DECRYPT_LASTBLOCK(S, OUT + i, IN + i, l); \
} \
} while(0)
#define FINALISE(S, K0, K1) \
do \
{ \
INJECT_DOMAIN_CONSTANT(S, FINAL_TAG); \
PERMUTE(S); \
INJECT_KEY(S, K0, K1); \
PERMUTE(S); \
INJECT_KEY(S, K0, K1); \
} while(0)
#define PAD(OUT, OUTLEN, IN, INLEN) \
do \
{ \
memset(OUT, 0, OUTLEN); \
memcpy(OUT, IN, INLEN); \
OUT[INLEN] = 0x01; \
OUT[OUTLEN - 1] |= 0x80; \
} while(0)
typedef enum tag__
{
HEADER_TAG = 0x01,
PAYLOAD_TAG = 0x02,
TRAILER_TAG = 0x04,
FINAL_TAG = 0x08,
BRANCH_TAG = 0x10,
MERGE_TAG = 0x20
} tag_t;
void norx_aead_encrypt(
unsigned char *c, size_t *clen,
const unsigned char *a, size_t alen,
const unsigned char *m, size_t mlen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce,
const unsigned char *key
)
{
const uint64x2_t K0 = LOADU(key + 0);
const uint64x2_t K1 = LOADU(key + 16);
uint64x2_t S[8];
*clen = mlen + BYTES(NORX_T);
INITIALISE(S, nonce, K0, K1);
ABSORB_DATA(S, a, alen, HEADER_TAG);
ENCRYPT_DATA(S, c, m, mlen);
ABSORB_DATA(S, z, zlen, TRAILER_TAG);
FINALISE(S, K0, K1);
STOREU(c + mlen, S[6]);
STOREU(c + mlen + BYTES(NORX_T)/2, S[7]);
}
int norx_aead_decrypt(
unsigned char *m, size_t *mlen,
const unsigned char *a, size_t alen,
const unsigned char *c, size_t clen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce,
const unsigned char *key
)
{
const uint64x2_t K0 = LOADU(key + 0);
const uint64x2_t K1 = LOADU(key + 16);
uint64x2_t S[8];
uint32x4_t T[2];
if (clen < BYTES(NORX_T)) { return -1; }
*mlen = clen - BYTES(NORX_T);
INITIALISE(S, nonce, K0, K1);
ABSORB_DATA(S, a, alen, HEADER_TAG);
DECRYPT_DATA(S, m, c, clen - BYTES(NORX_T));
ABSORB_DATA(S, z, zlen, TRAILER_TAG);
FINALISE(S, K0, K1);
/* Verify tag */
T[0] = vceqq_u32(U64TOU32(S[6]), U8TOU32( vld1q_u8((uint8_t *)(c + clen - BYTES(NORX_T) )) ));
T[1] = vceqq_u32(U64TOU32(S[7]), U8TOU32( vld1q_u8((uint8_t *)(c + clen - BYTES(NORX_T)/2)) ));
T[0] = vandq_u32(T[0], T[1]);
return 0xFFFFFFFFFFFFFFFFULL == (vgetq_lane_u64(U32TOU64(T[0]), 0) & vgetq_lane_u64(U32TOU64(T[0]), 1)) ? 0 : -1;
}
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
CFLAGS=-O3 -mavx2 -march=core-avx2 -std=c89 -Wall -pedantic -Wno-long-long
all: check bench
debug:
@$(CC) $(CFLAGS) -DNORX_DEBUG -I. -o debug ../../utils/debug.c norx.c
@./debug
@rm debug
bench:
@$(CC) $(CFLAGS) -o bench ../../utils/bench.c norx.c caesar.c
@./bench
@rm bench
check:
@$(CC) $(CFLAGS) -I../ -o check ../../utils/check.c norx.c caesar.c
@./check
@rm check
.PHONY: check debug bench
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
NORX reference source code package - reference C implementations
Written 2014-2015 by:
- Samuel Neves <[email protected]>
- Philipp Jovanovic <[email protected]>
To the extent possible under law, the author(s) have dedicated all copyright
and related and neighboring rights to this software to the public domain
worldwide. This software is distributed without any warranty.
You should have received a copy of the CC0 Public Domain Dedication along with
this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#define CRYPTO_KEYBYTES 32
#define CRYPTO_NSECBYTES 0
#define CRYPTO_NPUBBYTES 32
#define CRYPTO_ABYTES 32
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
NORX reference source code package - reference C implementations
Written 2014-2015 by:
- Samuel Neves <[email protected]>
- Philipp Jovanovic <[email protected]>
To the extent possible under law, the author(s) have dedicated all copyright
and related and neighboring rights to this software to the public domain
worldwide. This software is distributed without any warranty.
You should have received a copy of the CC0 Public Domain Dedication along with
this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#if defined(SUPERCOP)
# include "crypto_aead.h"
#endif
#include "api.h"
#include "norx.h"
/*
the code for the cipher implementation goes here,
generating a ciphertext c[0],c[1],...,c[*clen-1]
from a plaintext m[0],m[1],...,m[mlen-1]
and associated data ad[0],ad[1],...,ad[adlen-1]
and secret message number nsec[0],nsec[1],...
and public message number npub[0],npub[1],...
and secret key k[0],k[1],...
*/
int crypto_aead_encrypt(
unsigned char *c, unsigned long long *clen,
const unsigned char *m, unsigned long long mlen,
const unsigned char *ad, unsigned long long adlen,
const unsigned char *nsec,
const unsigned char *npub,
const unsigned char *k
)
{
size_t outlen = 0;
norx_aead_encrypt(c, &outlen, ad, adlen, m, mlen, NULL, 0, npub, k);
*clen = outlen;
(void)nsec; /* avoid warning */
return 0;
}
/*
the code for the cipher implementation goes here,
generating a plaintext m[0],m[1],...,m[*mlen-1]
and secret message number nsec[0],nsec[1],...
from a ciphertext c[0],c[1],...,c[clen-1]
and associated data ad[0],ad[1],...,ad[adlen-1]
and public message number npub[0],npub[1],...
and secret key k[0],k[1],...
*/
int crypto_aead_decrypt(
unsigned char *m, unsigned long long *mlen,
unsigned char *nsec,
const unsigned char *c, unsigned long long clen,
const unsigned char *ad, unsigned long long adlen,
const unsigned char *npub,
const unsigned char *k
)
{
size_t outlen = 0;
int result = norx_aead_decrypt(m, &outlen, ad, adlen, c, clen, NULL, 0, npub, k);
*mlen = outlen;
(void)nsec; /* avoid warning */
return result;
}
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
NORX reference source code package - reference C implementations
Written 2014-2015 by:
- Samuel Neves <[email protected]>
- Philipp Jovanovic <[email protected]>
To the extent possible under law, the author(s) have dedicated all copyright
and related and neighboring rights to this software to the public domain
worldwide. This software is distributed without any warranty.
You should have received a copy of the CC0 Public Domain Dedication along with
this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#ifndef NORX_NORX_H
#define NORX_NORX_H
#include <stddef.h>
#include <stdint.h>
/* High-level operations */
void norx_aead_encrypt(
unsigned char *c, size_t *clen,
const unsigned char *a, size_t alen,
const unsigned char *m, size_t mlen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce, const unsigned char *key);
int norx_aead_decrypt(
unsigned char *m, size_t *mlen,
const unsigned char *a, size_t alen,
const unsigned char *c, size_t clen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce, const unsigned char *key);
#endif
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
/*
NORX reference source code package - reference C implementations
Written 2014-2015 by:
- Samuel Neves <[email protected]>
- Philipp Jovanovic <[email protected]>
To the extent possible under law, the author(s) have dedicated all copyright
and related and neighboring rights to this software to the public domain
worldwide. This software is distributed without any warranty.
You should have received a copy of the CC0 Public Domain Dedication along with
this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#include <string.h>
#include "norx.h"
#if defined(_MSC_VER)
#include <intrin.h>
#else
#if defined(__XOP__)
#include <x86intrin.h>
#else
#include <immintrin.h>
#endif
#endif
const char * norx_version = "3.0";
#define NORX_W 64 /* word size */
#define NORX_L 4 /* round number */
#define NORX_P 1 /* parallelism degree */
#define NORX_T (NORX_W * 4) /* tag size */
#define NORX_N (NORX_W * 4) /* nonce size */
#define NORX_K (NORX_W * 4) /* key size */
#define NORX_B (NORX_W * 16) /* permutation width */
#define NORX_C (NORX_W * 4) /* capacity */
#define NORX_R (NORX_B - NORX_C) /* rate */
#define TWEAK_LOW_LATENCY
#define BYTES(x) (((x) + 7) / 8)
#define WORDS(x) (((x) + (NORX_W-1)) / NORX_W)
#if defined(_MSC_VER)
#define ALIGN(x) __declspec(align(x))
#else
#define ALIGN(x) __attribute__((aligned(x)))
#endif
#define LOAD(in) _mm256_load_si256((__m256i*)(in))
#define STORE(out, x) _mm256_store_si256((__m256i*)(out), (x))
#define LOADU(in) _mm256_loadu_si256((__m256i*)(in))
#define STOREU(out, x) _mm256_storeu_si256((__m256i*)(out), (x))
#define LOAD128(in) _mm_load_si128((__m128i*)(in))
#define STORE128(out, x) _mm_store_si128((__m128i*)(out), (x))
#define LOADU128(in) _mm_loadu_si128((__m128i*)(in))
#define STOREU128(out, x) _mm_storeu_si128((__m128i*)(out), (x))
#define TO128(x) _mm256_castsi256_si128(x)
#define TO256(x) _mm256_castsi128_si256(x)
#define ROT(X, C) \
( \
(C) == 8 ? _mm256_shuffle_epi8((X), _mm256_set_epi8(8,15,14,13,12,11,10,9, 0,7,6,5,4,3,2,1, 8,15,14,13,12,11,10,9, 0,7,6,5,4,3,2,1)) \
: (C) == 40 ? _mm256_shuffle_epi8((X), _mm256_set_epi8(12,11,10,9,8,15,14,13, 4,3,2,1,0,7,6,5, 12,11,10,9,8,15,14,13, 4,3,2,1,0,7,6,5)) \
: (C) == 63 ? _mm256_or_si256(_mm256_add_epi64((X), (X)), _mm256_srli_epi64((X), 63)) \
: /* else */ _mm256_or_si256(_mm256_srli_epi64((X), (C)), _mm256_slli_epi64((X), 64 - (C))) \
)
#define XOR(A, B) _mm256_xor_si256((A), (B))
#define AND(A, B) _mm256_and_si256((A), (B))
#define ADD(A, B) _mm256_add_epi64((A), (B))
#define XOR128(A, B) _mm_xor_si128((A), (B))
#define AND128(A, B) _mm_and_si128((A), (B))
#define ADD128(A, B) _mm_add_epi64((A), (B))
#define U0 0xE4D324772B91DF79ULL
#define U1 0x3AEC9ABAAEB02CCBULL
#define U2 0x9DFBA13DB4289311ULL
#define U3 0xEF9EB4BF5A97F2C8ULL
#define U4 0x3F466E92C1532034ULL
#define U5 0xE6E986626CC405C1ULL
#define U6 0xACE40F3B549184E1ULL
#define U7 0xD9CFD35762614477ULL
#define U8 0xB15E641748DE5E6BULL
#define U9 0xAA95E955E10F8410ULL
#define U10 0x28D1034441A9DD40ULL
#define U11 0x7F31BBF964E93BF5ULL
#define U12 0xB5E9E22493DFFB96ULL
#define U13 0xB980C852479FAFBDULL
#define U14 0xDA24516BF55EAFD4ULL
#define U15 0x86026AE8536F1501ULL
#define R0 8
#define R1 19
#define R2 40
#define R3 63
/* Implementation */
#if defined(TWEAK_LOW_LATENCY)
#define G(A, B, C, D) \
do \
{ \
__m256i t0, t1; \
\
t0 = XOR( A, B); \
t1 = AND( A, B); \
t1 = ADD(t1, t1); \
A = XOR(t0, t1); \
D = XOR( D, t0); \
D = XOR( D, t1); \
D = ROT( D, R0); \
\
t0 = XOR( C, D); \
t1 = AND( C, D); \
t1 = ADD(t1, t1); \
C = XOR(t0, t1); \
B = XOR( B, t0); \
B = XOR( B, t1); \
B = ROT( B, R1); \
\
t0 = XOR( A, B); \
t1 = AND( A, B); \
t1 = ADD(t1, t1); \
A = XOR(t0, t1); \
D = XOR( D, t0); \
D = XOR( D, t1); \
D = ROT( D, R2); \
\
t0 = XOR( C, D); \
t1 = AND( C, D); \
t1 = ADD(t1, t1); \
C = XOR(t0, t1); \
B = XOR( B, t0); \
B = XOR( B, t1); \
B = ROT( B, R3); \
} while(0)
#else
#define G(A, B, C, D) \
do \
{ \
__m256i t0, t1; \
\
t0 = XOR( A, B); \
t1 = AND( A, B); \
t1 = ADD(t1, t1); \
A = XOR(t0, t1); \
D = XOR( D, A); \
D = ROT( D, R0); \
\
t0 = XOR( C, D); \
t1 = AND( C, D); \
t1 = ADD(t1, t1); \
C = XOR(t0, t1); \
B = XOR( B, C); \
B = ROT( B, R1); \
\
t0 = XOR( A, B); \
t1 = AND( A, B); \
t1 = ADD(t1, t1); \
A = XOR(t0, t1); \
D = XOR( D, A); \
D = ROT( D, R2); \
\
t0 = XOR( C, D); \
t1 = AND( C, D); \
t1 = ADD(t1, t1); \
C = XOR(t0, t1); \
B = XOR( B, C); \
B = ROT( B, R3); \
} while(0)
#endif
#define DIAGONALIZE(A, B, C, D) \
do \
{ \
D = _mm256_permute4x64_epi64(D, _MM_SHUFFLE(2,1,0,3)); \
C = _mm256_permute4x64_epi64(C, _MM_SHUFFLE(1,0,3,2)); \
B = _mm256_permute4x64_epi64(B, _MM_SHUFFLE(0,3,2,1)); \
} while(0)
#define UNDIAGONALIZE(A, B, C, D) \
do \
{ \
D = _mm256_permute4x64_epi64(D, _MM_SHUFFLE(0,3,2,1)); \
C = _mm256_permute4x64_epi64(C, _MM_SHUFFLE(1,0,3,2)); \
B = _mm256_permute4x64_epi64(B, _MM_SHUFFLE(2,1,0,3)); \
} while(0)
#define F(A, B, C, D) \
do \
{ \
\
G(A, B, C, D); \
DIAGONALIZE(A, B, C, D); \
G(A, B, C, D); \
UNDIAGONALIZE(A, B, C, D); \
} while(0)
#define PERMUTE(A, B, C, D) \
do \
{ \
int i; \
for(i = 0; i < NORX_L; ++i) \
{ \
F(A, B, C, D); \
} \
} while(0)
#define INJECT_DOMAIN_CONSTANT(A, B, C, D, TAG) \
do \
{ \
D = XOR(D, _mm256_set_epi64x(TAG, 0, 0, 0)); \
} while(0)
#define INJECT_KEY(A, B, C, D, K) do { \
D = XOR(D, K); \
} while(0)
#define ABSORB_BLOCK(A, B, C, D, IN, TAG) \
do \
{ \
INJECT_DOMAIN_CONSTANT(A, B, C, D, TAG); \
PERMUTE(A, B, C, D); \
A = XOR(A, LOADU(IN + 0)); \
B = XOR(B, LOADU(IN + 32)); \
C = XOR(C, LOADU(IN + 64)); \
} while(0)
#define ABSORB_LASTBLOCK(A, B, C, D, IN, INLEN, TAG) \
do \
{ \
ALIGN(64) unsigned char lastblock[BYTES(NORX_R)]; \
PAD(lastblock, sizeof lastblock, IN, INLEN); \
ABSORB_BLOCK(A, B, C, D, lastblock, TAG); \
} while(0)
#define ENCRYPT_BLOCK(A, B, C, D, OUT, IN) \
do \
{ \
INJECT_DOMAIN_CONSTANT(A, B, C, D, PAYLOAD_TAG); \
PERMUTE(A, B, C, D); \
A = XOR(A, LOADU(IN + 0)); STOREU(OUT + 0, A); \
B = XOR(B, LOADU(IN + 32)); STOREU(OUT + 32, B); \
C = XOR(C, LOADU(IN + 64)); STOREU(OUT + 64, C); \
} while(0)
#define ENCRYPT_LASTBLOCK(A, B, C, D, OUT, IN, INLEN) \
do \
{ \
ALIGN(64) unsigned char lastblock[BYTES(NORX_R)]; \
PAD(lastblock, sizeof lastblock, IN, INLEN); \
ENCRYPT_BLOCK(A, B, C, D, lastblock, lastblock); \
memcpy(OUT, lastblock, INLEN); \
} while(0)
#define DECRYPT_BLOCK(A, B, C, D, OUT, IN) \
do \
{ \
__m256i W0, W1, W2; \
INJECT_DOMAIN_CONSTANT(A, B, C, D, PAYLOAD_TAG); \
PERMUTE(A, B, C, D); \
W0 = LOADU(IN + 0); STOREU(OUT + 0, XOR(A, W0)); A = W0; \
W1 = LOADU(IN + 32); STOREU(OUT + 32, XOR(B, W1)); B = W1; \
W2 = LOADU(IN + 64); STOREU(OUT + 64, XOR(C, W2)); C = W2; \
} while(0)
#define DECRYPT_LASTBLOCK(A, B, C, D, OUT, IN, INLEN) \
do \
{ \
__m256i W0, W1, W2; \
ALIGN(64) unsigned char lastblock[BYTES(NORX_R)] = {0}; \
INJECT_DOMAIN_CONSTANT(A, B, C, D, PAYLOAD_TAG); \
PERMUTE(A, B, C, D); \
STOREU(lastblock + 0, A); \
STOREU(lastblock + 32, B); \
STOREU(lastblock + 64, C); \
memcpy(lastblock, IN, INLEN); \
lastblock[INLEN] ^= 0x01; \
lastblock[BYTES(NORX_R)-1] ^= 0x80; \
W0 = LOADU(lastblock + 0); STOREU(lastblock + 0, XOR(A, W0)); A = W0; \
W1 = LOADU(lastblock + 32); STOREU(lastblock + 32, XOR(B, W1)); B = W1; \
W2 = LOADU(lastblock + 64); STOREU(lastblock + 64, XOR(C, W2)); C = W2; \
memcpy(OUT, lastblock, INLEN); \
} while(0)
#define INITIALISE(A, B, C, D, NONCE, K) \
do \
{ \
A = LOADU(NONCE); \
B = K; \
C = _mm256_set_epi64x(U11, U10, U9, U8); \
D = _mm256_set_epi64x(U15, U14, U13, U12); \
D = XOR(D, _mm256_set_epi64x(NORX_T, NORX_P, NORX_L, NORX_W)); \
PERMUTE(A, B, C, D); \
INJECT_KEY(A, B, C, D, K); \
} while(0)
#define ABSORB_DATA(A, B, C, D, IN, INLEN, TAG) \
do \
{ \
if (INLEN > 0) \
{ \
size_t i = 0; \
size_t l = INLEN; \
while (l >= BYTES(NORX_R)) \
{ \
ABSORB_BLOCK(A, B, C, D, IN + i, TAG); \
i += BYTES(NORX_R); \
l -= BYTES(NORX_R); \
} \
ABSORB_LASTBLOCK(A, B, C, D, IN + i, l, TAG); \
} \
} while(0)
#define ENCRYPT_DATA(A, B, C, D, OUT, IN, INLEN) \
do \
{ \
if (INLEN > 0) \
{ \
size_t i = 0; \
size_t l = INLEN; \
while (l >= BYTES(NORX_R)) \
{ \
ENCRYPT_BLOCK(A, B, C, D, OUT + i, IN + i); \
i += BYTES(NORX_R); \
l -= BYTES(NORX_R); \
} \
ENCRYPT_LASTBLOCK(A, B, C, D, OUT + i, IN + i, l); \
} \
} while(0)
#define DECRYPT_DATA(A, B, C, D, OUT, IN, INLEN) \
do \
{ \
if (INLEN > 0) \
{ \
size_t i = 0; \
size_t l = INLEN; \
while (l >= BYTES(NORX_R)) \
{ \
DECRYPT_BLOCK(A, B, C, D, OUT + i, IN + i); \
i += BYTES(NORX_R); \
l -= BYTES(NORX_R); \
} \
DECRYPT_LASTBLOCK(A, B, C, D, OUT + i, IN + i, l); \
} \
} while(0)
#define FINALISE(A, B, C, D, K) \
do \
{ \
INJECT_DOMAIN_CONSTANT(A, B, C, D, FINAL_TAG); \
PERMUTE(A, B, C, D); \
INJECT_KEY(A, B, C, D, K); \
PERMUTE(A, B, C, D); \
INJECT_KEY(A, B, C, D, K); \
} while(0)
#define PAD(OUT, OUTLEN, IN, INLEN) \
do \
{ \
memset(OUT, 0, OUTLEN); \
memcpy(OUT, IN, INLEN); \
OUT[INLEN] = 0x01; \
OUT[OUTLEN - 1] |= 0x80; \
} while(0)
typedef enum tag__
{
HEADER_TAG = 0x01,
PAYLOAD_TAG = 0x02,
TRAILER_TAG = 0x04,
FINAL_TAG = 0x08,
BRANCH_TAG = 0x10,
MERGE_TAG = 0x20
} tag_t;
void norx_aead_encrypt(
unsigned char *c, size_t *clen,
const unsigned char *a, size_t alen,
const unsigned char *m, size_t mlen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce,
const unsigned char *key
)
{
const __m256i K = LOADU(key);
__m256i A, B, C, D;
*clen = mlen + BYTES(NORX_T);
INITIALISE(A, B, C, D, nonce, K);
ABSORB_DATA(A, B, C, D, a, alen, HEADER_TAG);
ENCRYPT_DATA(A, B, C, D, c, m, mlen);
ABSORB_DATA(A, B, C, D, z, zlen, TRAILER_TAG);
FINALISE(A, B, C, D, K);
STOREU(c + mlen, D);
}
int norx_aead_decrypt(
unsigned char *m, size_t *mlen,
const unsigned char *a, size_t alen,
const unsigned char *c, size_t clen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce,
const unsigned char *key
)
{
const __m256i K = LOADU(key);
__m256i A, B, C, D;
if (clen < BYTES(NORX_T)) { return -1; }
*mlen = clen - BYTES(NORX_T);
INITIALISE(A, B, C, D, nonce, K);
ABSORB_DATA(A, B, C, D, a, alen, HEADER_TAG);
DECRYPT_DATA(A, B, C, D, m, c, clen - BYTES(NORX_T));
ABSORB_DATA(A, B, C, D, z, zlen, TRAILER_TAG);
FINALISE(A, B, C, D, K);
/* Verify tag */
D = _mm256_cmpeq_epi8(D, LOADU(c + clen - BYTES(NORX_T)));
return (((_mm256_movemask_epi8(D) & 0xFFFFFFFFULL) + 1) >> 32) - 1;
}
| {
"repo_name": "norx/norx",
"stars": "85",
"repo_language": "C",
"file_name": "norx.c",
"mime_type": "text/x-c"
} |
1.3.4
=====
This patch release squashes deprecation warnings for the `try!` macro, in
accordance with byteorder's minimum supported Rust version (currently at Rust
1.12.0).
1.3.3
=====
This patch release adds `ByteOrder::write_i8_into()` as a simple, safe interface
for ordinarily unsafe or tedious code.
1.3.2
=====
This patch release adds `ReadBytesExt::read_i8_into()` as a simple, safe interface
for ordinarily unsafe or tedious code.
1.3.1
=====
This minor release performs mostly small internal changes. Going forward, these
are not going to be incorporated into the changelog.
1.3.0
=====
This new minor release now enables `i128` support automatically on Rust
compilers that support 128-bit integers. The `i128` feature is now a no-op, but
continues to exist for backward compatibility purposes. The crate continues to
maintain compatibility with Rust 1.12.0.
This release also deprecates the `ByteOrder` trait methods
`read_f32_into_unchecked` and `read_f64_into_unchecked` in favor of
`read_f32_into` and `read_f64_into`. This was an oversight from the 1.2 release
where the corresponding methods on `ReadBytesExt` were deprecated.
`quickcheck` and `rand` were bumped to `0.8` and `0.6`, respectively.
A few small documentation related bugs have been fixed.
1.2.7
=====
This patch release excludes some CI files from the crate release and updates
the license field to use `OR` instead of `/`.
1.2.6
=====
This patch release fixes some test compilation errors introduced by an
over-eager release of 1.2.5.
1.2.5
=====
This patch release fixes some typos in the docs, adds doc tests to methods on
`WriteByteExt` and bumps the quickcheck dependency to `0.7`.
1.2.4
=====
This patch release adds support for 48-bit integers by adding the following
methods to the `ByteOrder` trait: `read_u48`, `read_i48`, `write_u48` and
`write_i48`. Corresponding methods have been added to the `ReadBytesExt` and
`WriteBytesExt` traits as well.
1.2.3
=====
This patch release removes the use of `feature(i128_type)` from byteorder,
since it has been stabilized. We leave byteorder's `i128` feature in place
in order to continue supporting compilation on older versions of Rust.
1.2.2
=====
This patch release only consists of internal improvements and refactorings.
Notably, this removes all uses of `transmute` and instead uses pointer casts.
1.2.1
=====
This patch release removes more unnecessary uses of `unsafe` that
were overlooked in the prior `1.2.0` release. In particular, the
`ReadBytesExt::read_{f32,f64}_into_checked` methods have been deprecated and
replaced by more appropriately named `read_{f32,f64}_into` methods.
1.2.0
=====
The most prominent change in this release of `byteorder` is the removal of
unnecessary signaling NaN masking, and in turn, the `unsafe` annotations
associated with methods that didn't do masking. See
[#103](https://github.com/BurntSushi/byteorder/issues/103)
for more details.
* [BUG #102](https://github.com/BurntSushi/byteorder/issues/102):
Fix big endian tests.
* [BUG #103](https://github.com/BurntSushi/byteorder/issues/103):
Remove sNaN masking.
1.1.0
=====
This release of `byteorder` features a number of fixes and improvements, mostly
as a result of the
[Litz Blitz evaluation](https://public.etherpad-mozilla.org/p/rust-crate-eval-byteorder).
Feature enhancements:
* [FEATURE #63](https://github.com/BurntSushi/byteorder/issues/63):
Add methods for reading/writing slices of numbers for a specific
endianness.
* [FEATURE #65](https://github.com/BurntSushi/byteorder/issues/65):
Add support for `u128`/`i128` types. (Behind the nightly only `i128`
feature.)
* [FEATURE #72](https://github.com/BurntSushi/byteorder/issues/72):
Add "panics" and "errors" sections for each relevant public API item.
* [FEATURE #74](https://github.com/BurntSushi/byteorder/issues/74):
Add CI badges to Cargo.toml.
* [FEATURE #75](https://github.com/BurntSushi/byteorder/issues/75):
Add more examples to public API items.
* Add 24-bit read/write methods.
* Add `BE` and `LE` type aliases for `BigEndian` and `LittleEndian`,
respectively.
Bug fixes:
* [BUG #68](https://github.com/BurntSushi/byteorder/issues/68):
Panic in {BigEndian,LittleEndian}::default.
* [BUG #69](https://github.com/BurntSushi/byteorder/issues/69):
Seal the `ByteOrder` trait to prevent out-of-crate implementations.
* [BUG #71](https://github.com/BurntSushi/byteorder/issues/71):
Guarantee that the results of `read_f32`/`read_f64` are always defined.
* [BUG #73](https://github.com/BurntSushi/byteorder/issues/73):
Add crates.io categories.
* [BUG #77](https://github.com/BurntSushi/byteorder/issues/77):
Add `html_root` doc attribute.
| {
"repo_name": "BurntSushi/byteorder",
"stars": "859",
"repo_language": "Rust",
"file_name": "bench.rs",
"mime_type": "text/plain"
} |
[package]
name = "byteorder"
version = "1.4.3" #:version
authors = ["Andrew Gallant <[email protected]>"]
description = "Library for reading/writing numbers in big-endian and little-endian."
documentation = "https://docs.rs/byteorder"
homepage = "https://github.com/BurntSushi/byteorder"
repository = "https://github.com/BurntSushi/byteorder"
readme = "README.md"
categories = ["encoding", "parsing", "no-std"]
keywords = ["byte", "endian", "big-endian", "little-endian", "binary"]
license = "Unlicense OR MIT"
exclude = ["/ci/*"]
edition = "2018"
[lib]
name = "byteorder"
bench = false
[dev-dependencies]
quickcheck = { version = "0.9.2", default-features = false }
rand = "0.7"
[features]
default = ["std"]
std = []
# This feature is no longer used and is DEPRECATED. This crate now
# automatically enables i128 support for Rust compilers that support it. The
# feature will be removed if and when a new major version is released.
i128 = []
[profile.bench]
opt-level = 3
| {
"repo_name": "BurntSushi/byteorder",
"stars": "859",
"repo_language": "Rust",
"file_name": "bench.rs",
"mime_type": "text/plain"
} |
max_width = 79
use_small_heuristics = "max"
| {
"repo_name": "BurntSushi/byteorder",
"stars": "859",
"repo_language": "Rust",
"file_name": "bench.rs",
"mime_type": "text/plain"
} |
This project is dual-licensed under the Unlicense and MIT licenses.
You may use this code under the terms of either license.
| {
"repo_name": "BurntSushi/byteorder",
"stars": "859",
"repo_language": "Rust",
"file_name": "bench.rs",
"mime_type": "text/plain"
} |
byteorder
=========
This crate provides convenience methods for encoding and decoding
numbers in either big-endian or little-endian order.
[](https://github.com/BurntSushi/byteorder/actions)
[](https://crates.io/crates/byteorder)
Dual-licensed under MIT or the [UNLICENSE](https://unlicense.org/).
### Documentation
https://docs.rs/byteorder
### Installation
This crate works with Cargo and is on
[crates.io](https://crates.io/crates/byteorder). Add it to your `Cargo.toml`
like so:
```toml
[dependencies]
byteorder = "1"
```
If you want to augment existing `Read` and `Write` traits, then import the
extension methods like so:
```rust
use byteorder::{ReadBytesExt, WriteBytesExt, BigEndian, LittleEndian};
```
For example:
```rust
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
// Note that we use type parameters to indicate which kind of byte order
// we want!
assert_eq!(517, rdr.read_u16::<BigEndian>().unwrap());
assert_eq!(768, rdr.read_u16::<BigEndian>().unwrap());
```
### `no_std` crates
This crate has a feature, `std`, that is enabled by default. To use this crate
in a `no_std` context, add the following to your `Cargo.toml`:
```toml
[dependencies]
byteorder = { version = "1", default-features = false }
```
### Minimum Rust version policy
This crate's minimum supported `rustc` version is `1.41.1`.
The current policy is that the minimum Rust version required to use this crate
can be increased in minor version updates. For example, if `crate 1.0` requires
Rust 1.20.0, then `crate 1.0.z` for all values of `z` will also require Rust
1.20.0 or newer. However, `crate 1.y` for `y > 0` may require a newer minimum
version of Rust.
In general, this crate will be conservative with respect to the minimum
supported version of Rust.
### Alternatives
Note that as of Rust 1.32, the standard numeric types provide built-in methods
like `to_le_bytes` and `from_le_bytes`, which support some of the same use
cases.
| {
"repo_name": "BurntSushi/byteorder",
"stars": "859",
"repo_language": "Rust",
"file_name": "bench.rs",
"mime_type": "text/plain"
} |
name: ci
on:
pull_request:
push:
branches:
- master
schedule:
- cron: '00 01 * * *'
jobs:
test:
name: test
env:
# For some builds, we use cross to test on 32-bit and big-endian
# systems.
CARGO: cargo
# When CARGO is set to CROSS, TARGET is set to `--target matrix.target`.
TARGET:
runs-on: ${{ matrix.os }}
strategy:
matrix:
build:
- pinned
- stable
- stable-32
- stable-mips
- beta
- nightly
- macos
- win-msvc
- win-gnu
include:
- build: pinned
os: ubuntu-latest
rust: 1.41.1
- build: stable
os: ubuntu-latest
rust: stable
- build: stable-32
os: ubuntu-latest
rust: stable
target: i686-unknown-linux-gnu
- build: stable-mips
os: ubuntu-latest
rust: stable
target: mips64-unknown-linux-gnuabi64
- build: beta
os: ubuntu-latest
rust: beta
- build: nightly
os: ubuntu-latest
rust: nightly
- build: macos
os: macos-latest
rust: stable
- build: win-msvc
os: windows-latest
rust: stable
- build: win-gnu
os: windows-latest
rust: stable-x86_64-gnu
steps:
- name: Checkout repository
uses: actions/checkout@v3
- name: Install Rust
uses: dtolnay/rust-toolchain@master
with:
toolchain: ${{ matrix.rust }}
- name: Use Cross
if: matrix.target != ''
run: |
# We used to install 'cross' from master, but it kept failing. So now
# we build from a known-good version until 'cross' becomes more stable
# or we find an alternative. Notably, between v0.2.1 and current
# master (2022-06-14), the number of Cross's dependencies has doubled.
cargo install --bins --git https://github.com/cross-rs/cross --tag v0.2.1
echo "CARGO=cross" >> $GITHUB_ENV
echo "TARGET=--target ${{ matrix.target }}" >> $GITHUB_ENV
- name: Show command used for Cargo
run: |
echo "cargo command is: ${{ env.CARGO }}"
echo "target flag is: ${{ env.TARGET }}"
- name: Show CPU info for debugging
if: matrix.os == 'ubuntu-latest'
run: lscpu
- name: Build
run: ${{ env.CARGO }} build --verbose $TARGET
- name: Build (no default)
run: ${{ env.CARGO }} build --verbose $TARGET --no-default-features
- name: Build docs
run: ${{ env.CARGO }} doc --verbose $TARGET
# Our dev dependencies evolve more rapidly than we'd like, so only run
# tests when we aren't pinning the Rust version.
- name: Tests
if: matrix.build != 'pinned'
run: ${{ env.CARGO }} test --verbose $TARGET
- name: Tests (no default, lib only)
if: matrix.build != 'pinned'
run: ${{ env.CARGO }} test --verbose --no-default-features --lib $TARGET
- name: Tests (i128)
if: matrix.build != 'pinned'
run: ${{ env.CARGO }} test --verbose --features i128 $TARGET
- name: Tests (no default, lib only, i128)
if: matrix.build != 'pinned'
run: ${{ env.CARGO }} test --verbose --no-default-features --features i128 --lib $TARGET
- name: Compile benchmarks
if: matrix.build == 'nightly'
run: cargo bench --verbose --no-run $TARGET
- name: Compile benchmarks (no default)
if: matrix.build == 'nightly'
run: cargo bench --verbose --no-run --no-default-features $TARGET
- name: Compile benchmarks (i128)
if: matrix.build == 'nightly'
run: cargo bench --verbose --no-run --features i128 $TARGET
- name: Compile benchmarks (no default, i128)
if: matrix.build == 'nightly'
run: cargo bench --verbose --no-run --no-default-features --features i128 $TARGET
rustfmt:
name: rustfmt
runs-on: ubuntu-latest
steps:
- name: Checkout repository
uses: actions/checkout@v3
- name: Install Rust
uses: dtolnay/rust-toolchain@master
with:
toolchain: stable
components: rustfmt
- name: Check formatting
run: cargo fmt -- --check
| {
"repo_name": "BurntSushi/byteorder",
"stars": "859",
"repo_language": "Rust",
"file_name": "bench.rs",
"mime_type": "text/plain"
} |
use std::{
io::{self, Result},
slice,
};
use crate::ByteOrder;
/// Extends [`Read`] with methods for reading numbers. (For `std::io`.)
///
/// Most of the methods defined here have an unconstrained type parameter that
/// must be explicitly instantiated. Typically, it is instantiated with either
/// the [`BigEndian`] or [`LittleEndian`] types defined in this crate.
///
/// # Examples
///
/// Read unsigned 16 bit big-endian integers from a [`Read`]:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
/// assert_eq!(517, rdr.read_u16::<BigEndian>().unwrap());
/// assert_eq!(768, rdr.read_u16::<BigEndian>().unwrap());
/// ```
///
/// [`BigEndian`]: enum.BigEndian.html
/// [`LittleEndian`]: enum.LittleEndian.html
/// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
pub trait ReadBytesExt: io::Read {
/// Reads an unsigned 8 bit integer from the underlying reader.
///
/// Note that since this reads a single byte, no byte order conversions
/// are used. It is included for completeness.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read unsigned 8 bit integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::ReadBytesExt;
///
/// let mut rdr = Cursor::new(vec![2, 5]);
/// assert_eq!(2, rdr.read_u8().unwrap());
/// assert_eq!(5, rdr.read_u8().unwrap());
/// ```
#[inline]
fn read_u8(&mut self) -> Result<u8> {
let mut buf = [0; 1];
self.read_exact(&mut buf)?;
Ok(buf[0])
}
/// Reads a signed 8 bit integer from the underlying reader.
///
/// Note that since this reads a single byte, no byte order conversions
/// are used. It is included for completeness.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read signed 8 bit integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::ReadBytesExt;
///
/// let mut rdr = Cursor::new(vec![0x02, 0xfb]);
/// assert_eq!(2, rdr.read_i8().unwrap());
/// assert_eq!(-5, rdr.read_i8().unwrap());
/// ```
#[inline]
fn read_i8(&mut self) -> Result<i8> {
let mut buf = [0; 1];
self.read_exact(&mut buf)?;
Ok(buf[0] as i8)
}
/// Reads an unsigned 16 bit integer from the underlying reader.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read unsigned 16 bit big-endian integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
/// assert_eq!(517, rdr.read_u16::<BigEndian>().unwrap());
/// assert_eq!(768, rdr.read_u16::<BigEndian>().unwrap());
/// ```
#[inline]
fn read_u16<T: ByteOrder>(&mut self) -> Result<u16> {
let mut buf = [0; 2];
self.read_exact(&mut buf)?;
Ok(T::read_u16(&buf))
}
/// Reads a signed 16 bit integer from the underlying reader.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read signed 16 bit big-endian integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![0x00, 0xc1, 0xff, 0x7c]);
/// assert_eq!(193, rdr.read_i16::<BigEndian>().unwrap());
/// assert_eq!(-132, rdr.read_i16::<BigEndian>().unwrap());
/// ```
#[inline]
fn read_i16<T: ByteOrder>(&mut self) -> Result<i16> {
let mut buf = [0; 2];
self.read_exact(&mut buf)?;
Ok(T::read_i16(&buf))
}
/// Reads an unsigned 24 bit integer from the underlying reader.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read unsigned 24 bit big-endian integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![0x00, 0x01, 0x0b]);
/// assert_eq!(267, rdr.read_u24::<BigEndian>().unwrap());
/// ```
#[inline]
fn read_u24<T: ByteOrder>(&mut self) -> Result<u32> {
let mut buf = [0; 3];
self.read_exact(&mut buf)?;
Ok(T::read_u24(&buf))
}
/// Reads a signed 24 bit integer from the underlying reader.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read signed 24 bit big-endian integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![0xff, 0x7a, 0x33]);
/// assert_eq!(-34253, rdr.read_i24::<BigEndian>().unwrap());
/// ```
#[inline]
fn read_i24<T: ByteOrder>(&mut self) -> Result<i32> {
let mut buf = [0; 3];
self.read_exact(&mut buf)?;
Ok(T::read_i24(&buf))
}
/// Reads an unsigned 32 bit integer from the underlying reader.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read unsigned 32 bit big-endian integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![0x00, 0x00, 0x01, 0x0b]);
/// assert_eq!(267, rdr.read_u32::<BigEndian>().unwrap());
/// ```
#[inline]
fn read_u32<T: ByteOrder>(&mut self) -> Result<u32> {
let mut buf = [0; 4];
self.read_exact(&mut buf)?;
Ok(T::read_u32(&buf))
}
/// Reads a signed 32 bit integer from the underlying reader.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read signed 32 bit big-endian integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![0xff, 0xff, 0x7a, 0x33]);
/// assert_eq!(-34253, rdr.read_i32::<BigEndian>().unwrap());
/// ```
#[inline]
fn read_i32<T: ByteOrder>(&mut self) -> Result<i32> {
let mut buf = [0; 4];
self.read_exact(&mut buf)?;
Ok(T::read_i32(&buf))
}
/// Reads an unsigned 48 bit integer from the underlying reader.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read unsigned 48 bit big-endian integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![0xb6, 0x71, 0x6b, 0xdc, 0x2b, 0x31]);
/// assert_eq!(200598257150769, rdr.read_u48::<BigEndian>().unwrap());
/// ```
#[inline]
fn read_u48<T: ByteOrder>(&mut self) -> Result<u64> {
let mut buf = [0; 6];
self.read_exact(&mut buf)?;
Ok(T::read_u48(&buf))
}
/// Reads a signed 48 bit integer from the underlying reader.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read signed 48 bit big-endian integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![0x9d, 0x71, 0xab, 0xe7, 0x97, 0x8f]);
/// assert_eq!(-108363435763825, rdr.read_i48::<BigEndian>().unwrap());
/// ```
#[inline]
fn read_i48<T: ByteOrder>(&mut self) -> Result<i64> {
let mut buf = [0; 6];
self.read_exact(&mut buf)?;
Ok(T::read_i48(&buf))
}
/// Reads an unsigned 64 bit integer from the underlying reader.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read an unsigned 64 bit big-endian integer from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83]);
/// assert_eq!(918733457491587, rdr.read_u64::<BigEndian>().unwrap());
/// ```
#[inline]
fn read_u64<T: ByteOrder>(&mut self) -> Result<u64> {
let mut buf = [0; 8];
self.read_exact(&mut buf)?;
Ok(T::read_u64(&buf))
}
/// Reads a signed 64 bit integer from the underlying reader.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read a signed 64 bit big-endian integer from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![0x80, 0, 0, 0, 0, 0, 0, 0]);
/// assert_eq!(i64::min_value(), rdr.read_i64::<BigEndian>().unwrap());
/// ```
#[inline]
fn read_i64<T: ByteOrder>(&mut self) -> Result<i64> {
let mut buf = [0; 8];
self.read_exact(&mut buf)?;
Ok(T::read_i64(&buf))
}
/// Reads an unsigned 128 bit integer from the underlying reader.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read an unsigned 128 bit big-endian integer from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![
/// 0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83,
/// 0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83
/// ]);
/// assert_eq!(16947640962301618749969007319746179, rdr.read_u128::<BigEndian>().unwrap());
/// ```
#[inline]
fn read_u128<T: ByteOrder>(&mut self) -> Result<u128> {
let mut buf = [0; 16];
self.read_exact(&mut buf)?;
Ok(T::read_u128(&buf))
}
/// Reads a signed 128 bit integer from the underlying reader.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read a signed 128 bit big-endian integer from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
/// assert_eq!(i128::min_value(), rdr.read_i128::<BigEndian>().unwrap());
/// ```
#[inline]
fn read_i128<T: ByteOrder>(&mut self) -> Result<i128> {
let mut buf = [0; 16];
self.read_exact(&mut buf)?;
Ok(T::read_i128(&buf))
}
/// Reads an unsigned n-bytes integer from the underlying reader.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read an unsigned n-byte big-endian integer from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![0x80, 0x74, 0xfa]);
/// assert_eq!(8418554, rdr.read_uint::<BigEndian>(3).unwrap());
#[inline]
fn read_uint<T: ByteOrder>(&mut self, nbytes: usize) -> Result<u64> {
let mut buf = [0; 8];
self.read_exact(&mut buf[..nbytes])?;
Ok(T::read_uint(&buf[..nbytes], nbytes))
}
/// Reads a signed n-bytes integer from the underlying reader.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read an unsigned n-byte big-endian integer from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![0xc1, 0xff, 0x7c]);
/// assert_eq!(-4063364, rdr.read_int::<BigEndian>(3).unwrap());
#[inline]
fn read_int<T: ByteOrder>(&mut self, nbytes: usize) -> Result<i64> {
let mut buf = [0; 8];
self.read_exact(&mut buf[..nbytes])?;
Ok(T::read_int(&buf[..nbytes], nbytes))
}
/// Reads an unsigned n-bytes integer from the underlying reader.
#[inline]
fn read_uint128<T: ByteOrder>(&mut self, nbytes: usize) -> Result<u128> {
let mut buf = [0; 16];
self.read_exact(&mut buf[..nbytes])?;
Ok(T::read_uint128(&buf[..nbytes], nbytes))
}
/// Reads a signed n-bytes integer from the underlying reader.
#[inline]
fn read_int128<T: ByteOrder>(&mut self, nbytes: usize) -> Result<i128> {
let mut buf = [0; 16];
self.read_exact(&mut buf[..nbytes])?;
Ok(T::read_int128(&buf[..nbytes], nbytes))
}
/// Reads a IEEE754 single-precision (4 bytes) floating point number from
/// the underlying reader.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read a big-endian single-precision floating point number from a `Read`:
///
/// ```rust
/// use std::f32;
/// use std::io::Cursor;
///
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![
/// 0x40, 0x49, 0x0f, 0xdb,
/// ]);
/// assert_eq!(f32::consts::PI, rdr.read_f32::<BigEndian>().unwrap());
/// ```
#[inline]
fn read_f32<T: ByteOrder>(&mut self) -> Result<f32> {
let mut buf = [0; 4];
self.read_exact(&mut buf)?;
Ok(T::read_f32(&buf))
}
/// Reads a IEEE754 double-precision (8 bytes) floating point number from
/// the underlying reader.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read a big-endian double-precision floating point number from a `Read`:
///
/// ```rust
/// use std::f64;
/// use std::io::Cursor;
///
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![
/// 0x40, 0x09, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18,
/// ]);
/// assert_eq!(f64::consts::PI, rdr.read_f64::<BigEndian>().unwrap());
/// ```
#[inline]
fn read_f64<T: ByteOrder>(&mut self) -> Result<f64> {
let mut buf = [0; 8];
self.read_exact(&mut buf)?;
Ok(T::read_f64(&buf))
}
/// Reads a sequence of unsigned 16 bit integers from the underlying
/// reader.
///
/// The given buffer is either filled completely or an error is returned.
/// If an error is returned, the contents of `dst` are unspecified.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read a sequence of unsigned 16 bit big-endian integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
/// let mut dst = [0; 2];
/// rdr.read_u16_into::<BigEndian>(&mut dst).unwrap();
/// assert_eq!([517, 768], dst);
/// ```
#[inline]
fn read_u16_into<T: ByteOrder>(&mut self, dst: &mut [u16]) -> Result<()> {
{
let buf = unsafe { slice_to_u8_mut(dst) };
self.read_exact(buf)?;
}
T::from_slice_u16(dst);
Ok(())
}
/// Reads a sequence of unsigned 32 bit integers from the underlying
/// reader.
///
/// The given buffer is either filled completely or an error is returned.
/// If an error is returned, the contents of `dst` are unspecified.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read a sequence of unsigned 32 bit big-endian integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![0, 0, 2, 5, 0, 0, 3, 0]);
/// let mut dst = [0; 2];
/// rdr.read_u32_into::<BigEndian>(&mut dst).unwrap();
/// assert_eq!([517, 768], dst);
/// ```
#[inline]
fn read_u32_into<T: ByteOrder>(&mut self, dst: &mut [u32]) -> Result<()> {
{
let buf = unsafe { slice_to_u8_mut(dst) };
self.read_exact(buf)?;
}
T::from_slice_u32(dst);
Ok(())
}
/// Reads a sequence of unsigned 64 bit integers from the underlying
/// reader.
///
/// The given buffer is either filled completely or an error is returned.
/// If an error is returned, the contents of `dst` are unspecified.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read a sequence of unsigned 64 bit big-endian integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![
/// 0, 0, 0, 0, 0, 0, 2, 5,
/// 0, 0, 0, 0, 0, 0, 3, 0,
/// ]);
/// let mut dst = [0; 2];
/// rdr.read_u64_into::<BigEndian>(&mut dst).unwrap();
/// assert_eq!([517, 768], dst);
/// ```
#[inline]
fn read_u64_into<T: ByteOrder>(&mut self, dst: &mut [u64]) -> Result<()> {
{
let buf = unsafe { slice_to_u8_mut(dst) };
self.read_exact(buf)?;
}
T::from_slice_u64(dst);
Ok(())
}
/// Reads a sequence of unsigned 128 bit integers from the underlying
/// reader.
///
/// The given buffer is either filled completely or an error is returned.
/// If an error is returned, the contents of `dst` are unspecified.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read a sequence of unsigned 128 bit big-endian integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![
/// 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 5,
/// 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0,
/// ]);
/// let mut dst = [0; 2];
/// rdr.read_u128_into::<BigEndian>(&mut dst).unwrap();
/// assert_eq!([517, 768], dst);
/// ```
#[inline]
fn read_u128_into<T: ByteOrder>(
&mut self,
dst: &mut [u128],
) -> Result<()> {
{
let buf = unsafe { slice_to_u8_mut(dst) };
self.read_exact(buf)?;
}
T::from_slice_u128(dst);
Ok(())
}
/// Reads a sequence of signed 8 bit integers from the underlying reader.
///
/// The given buffer is either filled completely or an error is returned.
/// If an error is returned, the contents of `dst` are unspecified.
///
/// Note that since each `i8` is a single byte, no byte order conversions
/// are used. This method is included because it provides a safe, simple
/// way for the caller to read into a `&mut [i8]` buffer. (Without this
/// method, the caller would have to either use `unsafe` code or convert
/// each byte to `i8` individually.)
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read a sequence of signed 8 bit integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![2, 251, 3]);
/// let mut dst = [0; 3];
/// rdr.read_i8_into(&mut dst).unwrap();
/// assert_eq!([2, -5, 3], dst);
/// ```
#[inline]
fn read_i8_into(&mut self, dst: &mut [i8]) -> Result<()> {
let buf = unsafe { slice_to_u8_mut(dst) };
self.read_exact(buf)
}
/// Reads a sequence of signed 16 bit integers from the underlying
/// reader.
///
/// The given buffer is either filled completely or an error is returned.
/// If an error is returned, the contents of `dst` are unspecified.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read a sequence of signed 16 bit big-endian integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
/// let mut dst = [0; 2];
/// rdr.read_i16_into::<BigEndian>(&mut dst).unwrap();
/// assert_eq!([517, 768], dst);
/// ```
#[inline]
fn read_i16_into<T: ByteOrder>(&mut self, dst: &mut [i16]) -> Result<()> {
{
let buf = unsafe { slice_to_u8_mut(dst) };
self.read_exact(buf)?;
}
T::from_slice_i16(dst);
Ok(())
}
/// Reads a sequence of signed 32 bit integers from the underlying
/// reader.
///
/// The given buffer is either filled completely or an error is returned.
/// If an error is returned, the contents of `dst` are unspecified.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read a sequence of signed 32 bit big-endian integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![0, 0, 2, 5, 0, 0, 3, 0]);
/// let mut dst = [0; 2];
/// rdr.read_i32_into::<BigEndian>(&mut dst).unwrap();
/// assert_eq!([517, 768], dst);
/// ```
#[inline]
fn read_i32_into<T: ByteOrder>(&mut self, dst: &mut [i32]) -> Result<()> {
{
let buf = unsafe { slice_to_u8_mut(dst) };
self.read_exact(buf)?;
}
T::from_slice_i32(dst);
Ok(())
}
/// Reads a sequence of signed 64 bit integers from the underlying
/// reader.
///
/// The given buffer is either filled completely or an error is returned.
/// If an error is returned, the contents of `dst` are unspecified.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read a sequence of signed 64 bit big-endian integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![
/// 0, 0, 0, 0, 0, 0, 2, 5,
/// 0, 0, 0, 0, 0, 0, 3, 0,
/// ]);
/// let mut dst = [0; 2];
/// rdr.read_i64_into::<BigEndian>(&mut dst).unwrap();
/// assert_eq!([517, 768], dst);
/// ```
#[inline]
fn read_i64_into<T: ByteOrder>(&mut self, dst: &mut [i64]) -> Result<()> {
{
let buf = unsafe { slice_to_u8_mut(dst) };
self.read_exact(buf)?;
}
T::from_slice_i64(dst);
Ok(())
}
/// Reads a sequence of signed 128 bit integers from the underlying
/// reader.
///
/// The given buffer is either filled completely or an error is returned.
/// If an error is returned, the contents of `dst` are unspecified.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read a sequence of signed 128 bit big-endian integers from a `Read`:
///
/// ```rust
/// use std::io::Cursor;
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![
/// 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 5,
/// 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0,
/// ]);
/// let mut dst = [0; 2];
/// rdr.read_i128_into::<BigEndian>(&mut dst).unwrap();
/// assert_eq!([517, 768], dst);
/// ```
#[inline]
fn read_i128_into<T: ByteOrder>(
&mut self,
dst: &mut [i128],
) -> Result<()> {
{
let buf = unsafe { slice_to_u8_mut(dst) };
self.read_exact(buf)?;
}
T::from_slice_i128(dst);
Ok(())
}
/// Reads a sequence of IEEE754 single-precision (4 bytes) floating
/// point numbers from the underlying reader.
///
/// The given buffer is either filled completely or an error is returned.
/// If an error is returned, the contents of `dst` are unspecified.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read a sequence of big-endian single-precision floating point number
/// from a `Read`:
///
/// ```rust
/// use std::f32;
/// use std::io::Cursor;
///
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![
/// 0x40, 0x49, 0x0f, 0xdb,
/// 0x3f, 0x80, 0x00, 0x00,
/// ]);
/// let mut dst = [0.0; 2];
/// rdr.read_f32_into::<BigEndian>(&mut dst).unwrap();
/// assert_eq!([f32::consts::PI, 1.0], dst);
/// ```
#[inline]
fn read_f32_into<T: ByteOrder>(&mut self, dst: &mut [f32]) -> Result<()> {
{
let buf = unsafe { slice_to_u8_mut(dst) };
self.read_exact(buf)?;
}
T::from_slice_f32(dst);
Ok(())
}
/// **DEPRECATED**.
///
/// This method is deprecated. Use `read_f32_into` instead.
///
/// Reads a sequence of IEEE754 single-precision (4 bytes) floating
/// point numbers from the underlying reader.
///
/// The given buffer is either filled completely or an error is returned.
/// If an error is returned, the contents of `dst` are unspecified.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read a sequence of big-endian single-precision floating point number
/// from a `Read`:
///
/// ```rust
/// use std::f32;
/// use std::io::Cursor;
///
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![
/// 0x40, 0x49, 0x0f, 0xdb,
/// 0x3f, 0x80, 0x00, 0x00,
/// ]);
/// let mut dst = [0.0; 2];
/// rdr.read_f32_into_unchecked::<BigEndian>(&mut dst).unwrap();
/// assert_eq!([f32::consts::PI, 1.0], dst);
/// ```
#[inline]
#[deprecated(since = "1.2.0", note = "please use `read_f32_into` instead")]
fn read_f32_into_unchecked<T: ByteOrder>(
&mut self,
dst: &mut [f32],
) -> Result<()> {
self.read_f32_into::<T>(dst)
}
/// Reads a sequence of IEEE754 double-precision (8 bytes) floating
/// point numbers from the underlying reader.
///
/// The given buffer is either filled completely or an error is returned.
/// If an error is returned, the contents of `dst` are unspecified.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read a sequence of big-endian single-precision floating point number
/// from a `Read`:
///
/// ```rust
/// use std::f64;
/// use std::io::Cursor;
///
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![
/// 0x40, 0x09, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18,
/// 0x3f, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/// ]);
/// let mut dst = [0.0; 2];
/// rdr.read_f64_into::<BigEndian>(&mut dst).unwrap();
/// assert_eq!([f64::consts::PI, 1.0], dst);
/// ```
#[inline]
fn read_f64_into<T: ByteOrder>(&mut self, dst: &mut [f64]) -> Result<()> {
{
let buf = unsafe { slice_to_u8_mut(dst) };
self.read_exact(buf)?;
}
T::from_slice_f64(dst);
Ok(())
}
/// **DEPRECATED**.
///
/// This method is deprecated. Use `read_f64_into` instead.
///
/// Reads a sequence of IEEE754 double-precision (8 bytes) floating
/// point numbers from the underlying reader.
///
/// The given buffer is either filled completely or an error is returned.
/// If an error is returned, the contents of `dst` are unspecified.
///
/// # Safety
///
/// This method is unsafe because there are no guarantees made about the
/// floating point values. In particular, this method does not check for
/// signaling NaNs, which may result in undefined behavior.
///
/// # Errors
///
/// This method returns the same errors as [`Read::read_exact`].
///
/// [`Read::read_exact`]: https://doc.rust-lang.org/std/io/trait.Read.html#method.read_exact
///
/// # Examples
///
/// Read a sequence of big-endian single-precision floating point number
/// from a `Read`:
///
/// ```rust
/// use std::f64;
/// use std::io::Cursor;
///
/// use byteorder::{BigEndian, ReadBytesExt};
///
/// let mut rdr = Cursor::new(vec![
/// 0x40, 0x09, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18,
/// 0x3f, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/// ]);
/// let mut dst = [0.0; 2];
/// rdr.read_f64_into_unchecked::<BigEndian>(&mut dst).unwrap();
/// assert_eq!([f64::consts::PI, 1.0], dst);
/// ```
#[inline]
#[deprecated(since = "1.2.0", note = "please use `read_f64_into` instead")]
fn read_f64_into_unchecked<T: ByteOrder>(
&mut self,
dst: &mut [f64],
) -> Result<()> {
self.read_f64_into::<T>(dst)
}
}
/// All types that implement `Read` get methods defined in `ReadBytesExt`
/// for free.
impl<R: io::Read + ?Sized> ReadBytesExt for R {}
/// Extends [`Write`] with methods for writing numbers. (For `std::io`.)
///
/// Most of the methods defined here have an unconstrained type parameter that
/// must be explicitly instantiated. Typically, it is instantiated with either
/// the [`BigEndian`] or [`LittleEndian`] types defined in this crate.
///
/// # Examples
///
/// Write unsigned 16 bit big-endian integers to a [`Write`]:
///
/// ```rust
/// use byteorder::{BigEndian, WriteBytesExt};
///
/// let mut wtr = vec![];
/// wtr.write_u16::<BigEndian>(517).unwrap();
/// wtr.write_u16::<BigEndian>(768).unwrap();
/// assert_eq!(wtr, vec![2, 5, 3, 0]);
/// ```
///
/// [`BigEndian`]: enum.BigEndian.html
/// [`LittleEndian`]: enum.LittleEndian.html
/// [`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
pub trait WriteBytesExt: io::Write {
/// Writes an unsigned 8 bit integer to the underlying writer.
///
/// Note that since this writes a single byte, no byte order conversions
/// are used. It is included for completeness.
///
/// # Errors
///
/// This method returns the same errors as [`Write::write_all`].
///
/// [`Write::write_all`]: https://doc.rust-lang.org/std/io/trait.Write.html#method.write_all
///
/// # Examples
///
/// Write unsigned 8 bit integers to a `Write`:
///
/// ```rust
/// use byteorder::WriteBytesExt;
///
/// let mut wtr = Vec::new();
/// wtr.write_u8(2).unwrap();
/// wtr.write_u8(5).unwrap();
/// assert_eq!(wtr, b"\x02\x05");
/// ```
#[inline]
fn write_u8(&mut self, n: u8) -> Result<()> {
self.write_all(&[n])
}
/// Writes a signed 8 bit integer to the underlying writer.
///
/// Note that since this writes a single byte, no byte order conversions
/// are used. It is included for completeness.
///
/// # Errors
///
/// This method returns the same errors as [`Write::write_all`].
///
/// [`Write::write_all`]: https://doc.rust-lang.org/std/io/trait.Write.html#method.write_all
///
/// # Examples
///
/// Write signed 8 bit integers to a `Write`:
///
/// ```rust
/// use byteorder::WriteBytesExt;
///
/// let mut wtr = Vec::new();
/// wtr.write_i8(2).unwrap();
/// wtr.write_i8(-5).unwrap();
/// assert_eq!(wtr, b"\x02\xfb");
/// ```
#[inline]
fn write_i8(&mut self, n: i8) -> Result<()> {
self.write_all(&[n as u8])
}
/// Writes an unsigned 16 bit integer to the underlying writer.
///
/// # Errors
///
/// This method returns the same errors as [`Write::write_all`].
///
/// [`Write::write_all`]: https://doc.rust-lang.org/std/io/trait.Write.html#method.write_all
///
/// # Examples
///
/// Write unsigned 16 bit big-endian integers to a `Write`:
///
/// ```rust
/// use byteorder::{BigEndian, WriteBytesExt};
///
/// let mut wtr = Vec::new();
/// wtr.write_u16::<BigEndian>(517).unwrap();
/// wtr.write_u16::<BigEndian>(768).unwrap();
/// assert_eq!(wtr, b"\x02\x05\x03\x00");
/// ```
#[inline]
fn write_u16<T: ByteOrder>(&mut self, n: u16) -> Result<()> {
let mut buf = [0; 2];
T::write_u16(&mut buf, n);
self.write_all(&buf)
}
/// Writes a signed 16 bit integer to the underlying writer.
///
/// # Errors
///
/// This method returns the same errors as [`Write::write_all`].
///
/// [`Write::write_all`]: https://doc.rust-lang.org/std/io/trait.Write.html#method.write_all
///
/// # Examples
///
/// Write signed 16 bit big-endian integers to a `Write`:
///
/// ```rust
/// use byteorder::{BigEndian, WriteBytesExt};
///
/// let mut wtr = Vec::new();
/// wtr.write_i16::<BigEndian>(193).unwrap();
/// wtr.write_i16::<BigEndian>(-132).unwrap();
/// assert_eq!(wtr, b"\x00\xc1\xff\x7c");
/// ```
#[inline]
fn write_i16<T: ByteOrder>(&mut self, n: i16) -> Result<()> {
let mut buf = [0; 2];
T::write_i16(&mut buf, n);
self.write_all(&buf)
}
/// Writes an unsigned 24 bit integer to the underlying writer.
///
/// # Errors
///
/// This method returns the same errors as [`Write::write_all`].
///
/// [`Write::write_all`]: https://doc.rust-lang.org/std/io/trait.Write.html#method.write_all
///
/// # Examples
///
/// Write unsigned 24 bit big-endian integers to a `Write`:
///
/// ```rust
/// use byteorder::{BigEndian, WriteBytesExt};
///
/// let mut wtr = Vec::new();
/// wtr.write_u24::<BigEndian>(267).unwrap();
/// wtr.write_u24::<BigEndian>(120111).unwrap();
/// assert_eq!(wtr, b"\x00\x01\x0b\x01\xd5\x2f");
/// ```
#[inline]
fn write_u24<T: ByteOrder>(&mut self, n: u32) -> Result<()> {
let mut buf = [0; 3];
T::write_u24(&mut buf, n);
self.write_all(&buf)
}
/// Writes a signed 24 bit integer to the underlying writer.
///
/// # Errors
///
/// This method returns the same errors as [`Write::write_all`].
///
/// [`Write::write_all`]: https://doc.rust-lang.org/std/io/trait.Write.html#method.write_all
///
/// # Examples
///
/// Write signed 24 bit big-endian integers to a `Write`:
///
/// ```rust
/// use byteorder::{BigEndian, WriteBytesExt};
///
/// let mut wtr = Vec::new();
/// wtr.write_i24::<BigEndian>(-34253).unwrap();
/// wtr.write_i24::<BigEndian>(120111).unwrap();
/// assert_eq!(wtr, b"\xff\x7a\x33\x01\xd5\x2f");
/// ```
#[inline]
fn write_i24<T: ByteOrder>(&mut self, n: i32) -> Result<()> {
let mut buf = [0; 3];
T::write_i24(&mut buf, n);
self.write_all(&buf)
}
/// Writes an unsigned 32 bit integer to the underlying writer.
///
/// # Errors
///
/// This method returns the same errors as [`Write::write_all`].
///
/// [`Write::write_all`]: https://doc.rust-lang.org/std/io/trait.Write.html#method.write_all
///
/// # Examples
///
/// Write unsigned 32 bit big-endian integers to a `Write`:
///
/// ```rust
/// use byteorder::{BigEndian, WriteBytesExt};
///
/// let mut wtr = Vec::new();
/// wtr.write_u32::<BigEndian>(267).unwrap();
/// wtr.write_u32::<BigEndian>(1205419366).unwrap();
/// assert_eq!(wtr, b"\x00\x00\x01\x0b\x47\xd9\x3d\x66");
/// ```
#[inline]
fn write_u32<T: ByteOrder>(&mut self, n: u32) -> Result<()> {
let mut buf = [0; 4];
T::write_u32(&mut buf, n);
self.write_all(&buf)
}
/// Writes a signed 32 bit integer to the underlying writer.
///
/// # Errors
///
/// This method returns the same errors as [`Write::write_all`].
///
/// [`Write::write_all`]: https://doc.rust-lang.org/std/io/trait.Write.html#method.write_all
///
/// # Examples
///
/// Write signed 32 bit big-endian integers to a `Write`:
///
/// ```rust
/// use byteorder::{BigEndian, WriteBytesExt};
///
/// let mut wtr = Vec::new();
/// wtr.write_i32::<BigEndian>(-34253).unwrap();
/// wtr.write_i32::<BigEndian>(1205419366).unwrap();
/// assert_eq!(wtr, b"\xff\xff\x7a\x33\x47\xd9\x3d\x66");
/// ```
#[inline]
fn write_i32<T: ByteOrder>(&mut self, n: i32) -> Result<()> {
let mut buf = [0; 4];
T::write_i32(&mut buf, n);
self.write_all(&buf)
}
/// Writes an unsigned 48 bit integer to the underlying writer.
///
/// # Errors
///
/// This method returns the same errors as [`Write::write_all`].
///
/// [`Write::write_all`]: https://doc.rust-lang.org/std/io/trait.Write.html#method.write_all
///
/// # Examples
///
/// Write unsigned 48 bit big-endian integers to a `Write`:
///
/// ```rust
/// use byteorder::{BigEndian, WriteBytesExt};
///
/// let mut wtr = Vec::new();
/// wtr.write_u48::<BigEndian>(52360336390828).unwrap();
/// wtr.write_u48::<BigEndian>(541).unwrap();
/// assert_eq!(wtr, b"\x2f\x9f\x17\x40\x3a\xac\x00\x00\x00\x00\x02\x1d");
/// ```
#[inline]
fn write_u48<T: ByteOrder>(&mut self, n: u64) -> Result<()> {
let mut buf = [0; 6];
T::write_u48(&mut buf, n);
self.write_all(&buf)
}
/// Writes a signed 48 bit integer to the underlying writer.
///
/// # Errors
///
/// This method returns the same errors as [`Write::write_all`].
///
/// [`Write::write_all`]: https://doc.rust-lang.org/std/io/trait.Write.html#method.write_all
///
/// # Examples
///
/// Write signed 48 bit big-endian integers to a `Write`:
///
/// ```rust
/// use byteorder::{BigEndian, WriteBytesExt};
///
/// let mut wtr = Vec::new();
/// wtr.write_i48::<BigEndian>(-108363435763825).unwrap();
/// wtr.write_i48::<BigEndian>(77).unwrap();
/// assert_eq!(wtr, b"\x9d\x71\xab\xe7\x97\x8f\x00\x00\x00\x00\x00\x4d");
/// ```
#[inline]
fn write_i48<T: ByteOrder>(&mut self, n: i64) -> Result<()> {
let mut buf = [0; 6];
T::write_i48(&mut buf, n);
self.write_all(&buf)
}
/// Writes an unsigned 64 bit integer to the underlying writer.
///
/// # Errors
///
/// This method returns the same errors as [`Write::write_all`].
///
/// [`Write::write_all`]: https://doc.rust-lang.org/std/io/trait.Write.html#method.write_all
///
/// # Examples
///
/// Write unsigned 64 bit big-endian integers to a `Write`:
///
/// ```rust
/// use byteorder::{BigEndian, WriteBytesExt};
///
/// let mut wtr = Vec::new();
/// wtr.write_u64::<BigEndian>(918733457491587).unwrap();
/// wtr.write_u64::<BigEndian>(143).unwrap();
/// assert_eq!(wtr, b"\x00\x03\x43\x95\x4d\x60\x86\x83\x00\x00\x00\x00\x00\x00\x00\x8f");
/// ```
#[inline]
fn write_u64<T: ByteOrder>(&mut self, n: u64) -> Result<()> {
let mut buf = [0; 8];
T::write_u64(&mut buf, n);
self.write_all(&buf)
}
/// Writes a signed 64 bit integer to the underlying writer.
///
/// # Errors
///
/// This method returns the same errors as [`Write::write_all`].
///
/// [`Write::write_all`]: https://doc.rust-lang.org/std/io/trait.Write.html#method.write_all
///
/// # Examples
///
/// Write signed 64 bit big-endian integers to a `Write`:
///
/// ```rust
/// use byteorder::{BigEndian, WriteBytesExt};
///
/// let mut wtr = Vec::new();
/// wtr.write_i64::<BigEndian>(i64::min_value()).unwrap();
/// wtr.write_i64::<BigEndian>(i64::max_value()).unwrap();
/// assert_eq!(wtr, b"\x80\x00\x00\x00\x00\x00\x00\x00\x7f\xff\xff\xff\xff\xff\xff\xff");
/// ```
#[inline]
fn write_i64<T: ByteOrder>(&mut self, n: i64) -> Result<()> {
let mut buf = [0; 8];
T::write_i64(&mut buf, n);
self.write_all(&buf)
}
/// Writes an unsigned 128 bit integer to the underlying writer.
#[inline]
fn write_u128<T: ByteOrder>(&mut self, n: u128) -> Result<()> {
let mut buf = [0; 16];
T::write_u128(&mut buf, n);
self.write_all(&buf)
}
/// Writes a signed 128 bit integer to the underlying writer.
#[inline]
fn write_i128<T: ByteOrder>(&mut self, n: i128) -> Result<()> {
let mut buf = [0; 16];
T::write_i128(&mut buf, n);
self.write_all(&buf)
}
/// Writes an unsigned n-bytes integer to the underlying writer.
///
/// # Errors
///
/// This method returns the same errors as [`Write::write_all`].
///
/// [`Write::write_all`]: https://doc.rust-lang.org/std/io/trait.Write.html#method.write_all
///
/// # Panics
///
/// If the given integer is not representable in the given number of bytes,
/// this method panics. If `nbytes > 8`, this method panics.
///
/// # Examples
///
/// Write unsigned 40 bit big-endian integers to a `Write`:
///
/// ```rust
/// use byteorder::{BigEndian, WriteBytesExt};
///
/// let mut wtr = Vec::new();
/// wtr.write_uint::<BigEndian>(312550384361, 5).unwrap();
/// wtr.write_uint::<BigEndian>(43, 5).unwrap();
/// assert_eq!(wtr, b"\x48\xc5\x74\x62\xe9\x00\x00\x00\x00\x2b");
/// ```
#[inline]
fn write_uint<T: ByteOrder>(
&mut self,
n: u64,
nbytes: usize,
) -> Result<()> {
let mut buf = [0; 8];
T::write_uint(&mut buf, n, nbytes);
self.write_all(&buf[0..nbytes])
}
/// Writes a signed n-bytes integer to the underlying writer.
///
/// # Errors
///
/// This method returns the same errors as [`Write::write_all`].
///
/// [`Write::write_all`]: https://doc.rust-lang.org/std/io/trait.Write.html#method.write_all
///
/// # Panics
///
/// If the given integer is not representable in the given number of bytes,
/// this method panics. If `nbytes > 8`, this method panics.
///
/// # Examples
///
/// Write signed 56 bit big-endian integers to a `Write`:
///
/// ```rust
/// use byteorder::{BigEndian, WriteBytesExt};
///
/// let mut wtr = Vec::new();
/// wtr.write_int::<BigEndian>(-3548172039376767, 7).unwrap();
/// wtr.write_int::<BigEndian>(43, 7).unwrap();
/// assert_eq!(wtr, b"\xf3\x64\xf4\xd1\xfd\xb0\x81\x00\x00\x00\x00\x00\x00\x2b");
/// ```
#[inline]
fn write_int<T: ByteOrder>(
&mut self,
n: i64,
nbytes: usize,
) -> Result<()> {
let mut buf = [0; 8];
T::write_int(&mut buf, n, nbytes);
self.write_all(&buf[0..nbytes])
}
/// Writes an unsigned n-bytes integer to the underlying writer.
///
/// If the given integer is not representable in the given number of bytes,
/// this method panics. If `nbytes > 16`, this method panics.
#[inline]
fn write_uint128<T: ByteOrder>(
&mut self,
n: u128,
nbytes: usize,
) -> Result<()> {
let mut buf = [0; 16];
T::write_uint128(&mut buf, n, nbytes);
self.write_all(&buf[0..nbytes])
}
/// Writes a signed n-bytes integer to the underlying writer.
///
/// If the given integer is not representable in the given number of bytes,
/// this method panics. If `nbytes > 16`, this method panics.
#[inline]
fn write_int128<T: ByteOrder>(
&mut self,
n: i128,
nbytes: usize,
) -> Result<()> {
let mut buf = [0; 16];
T::write_int128(&mut buf, n, nbytes);
self.write_all(&buf[0..nbytes])
}
/// Writes a IEEE754 single-precision (4 bytes) floating point number to
/// the underlying writer.
///
/// # Errors
///
/// This method returns the same errors as [`Write::write_all`].
///
/// [`Write::write_all`]: https://doc.rust-lang.org/std/io/trait.Write.html#method.write_all
///
/// # Examples
///
/// Write a big-endian single-precision floating point number to a `Write`:
///
/// ```rust
/// use std::f32;
///
/// use byteorder::{BigEndian, WriteBytesExt};
///
/// let mut wtr = Vec::new();
/// wtr.write_f32::<BigEndian>(f32::consts::PI).unwrap();
/// assert_eq!(wtr, b"\x40\x49\x0f\xdb");
/// ```
#[inline]
fn write_f32<T: ByteOrder>(&mut self, n: f32) -> Result<()> {
let mut buf = [0; 4];
T::write_f32(&mut buf, n);
self.write_all(&buf)
}
/// Writes a IEEE754 double-precision (8 bytes) floating point number to
/// the underlying writer.
///
/// # Errors
///
/// This method returns the same errors as [`Write::write_all`].
///
/// [`Write::write_all`]: https://doc.rust-lang.org/std/io/trait.Write.html#method.write_all
///
/// # Examples
///
/// Write a big-endian double-precision floating point number to a `Write`:
///
/// ```rust
/// use std::f64;
///
/// use byteorder::{BigEndian, WriteBytesExt};
///
/// let mut wtr = Vec::new();
/// wtr.write_f64::<BigEndian>(f64::consts::PI).unwrap();
/// assert_eq!(wtr, b"\x40\x09\x21\xfb\x54\x44\x2d\x18");
/// ```
#[inline]
fn write_f64<T: ByteOrder>(&mut self, n: f64) -> Result<()> {
let mut buf = [0; 8];
T::write_f64(&mut buf, n);
self.write_all(&buf)
}
}
/// All types that implement `Write` get methods defined in `WriteBytesExt`
/// for free.
impl<W: io::Write + ?Sized> WriteBytesExt for W {}
/// Convert a slice of T (where T is plain old data) to its mutable binary
/// representation.
///
/// This function is wildly unsafe because it permits arbitrary modification of
/// the binary representation of any `Copy` type. Use with care. It's intended
/// to be called only where `T` is a numeric type.
unsafe fn slice_to_u8_mut<T: Copy>(slice: &mut [T]) -> &mut [u8] {
use std::mem::size_of;
let len = size_of::<T>() * slice.len();
slice::from_raw_parts_mut(slice.as_mut_ptr() as *mut u8, len)
}
| {
"repo_name": "BurntSushi/byteorder",
"stars": "859",
"repo_language": "Rust",
"file_name": "bench.rs",
"mime_type": "text/plain"
} |
/*!
This crate provides convenience methods for encoding and decoding numbers in
either [big-endian or little-endian order].
The organization of the crate is pretty simple. A trait, [`ByteOrder`], specifies
byte conversion methods for each type of number in Rust (sans numbers that have
a platform dependent size like `usize` and `isize`). Two types, [`BigEndian`]
and [`LittleEndian`] implement these methods. Finally, [`ReadBytesExt`] and
[`WriteBytesExt`] provide convenience methods available to all types that
implement [`Read`] and [`Write`].
An alias, [`NetworkEndian`], for [`BigEndian`] is provided to help improve
code clarity.
An additional alias, [`NativeEndian`], is provided for the endianness of the
local platform. This is convenient when serializing data for use and
conversions are not desired.
# Examples
Read unsigned 16 bit big-endian integers from a [`Read`] type:
```rust
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
// Note that we use type parameters to indicate which kind of byte order
// we want!
assert_eq!(517, rdr.read_u16::<BigEndian>().unwrap());
assert_eq!(768, rdr.read_u16::<BigEndian>().unwrap());
```
Write unsigned 16 bit little-endian integers to a [`Write`] type:
```rust
use byteorder::{LittleEndian, WriteBytesExt};
let mut wtr = vec![];
wtr.write_u16::<LittleEndian>(517).unwrap();
wtr.write_u16::<LittleEndian>(768).unwrap();
assert_eq!(wtr, vec![5, 2, 0, 3]);
```
# Optional Features
This crate optionally provides support for 128 bit values (`i128` and `u128`)
when built with the `i128` feature enabled.
This crate can also be used without the standard library.
# Alternatives
Note that as of Rust 1.32, the standard numeric types provide built-in methods
like `to_le_bytes` and `from_le_bytes`, which support some of the same use
cases.
[big-endian or little-endian order]: https://en.wikipedia.org/wiki/Endianness
[`ByteOrder`]: trait.ByteOrder.html
[`BigEndian`]: enum.BigEndian.html
[`LittleEndian`]: enum.LittleEndian.html
[`ReadBytesExt`]: trait.ReadBytesExt.html
[`WriteBytesExt`]: trait.WriteBytesExt.html
[`NetworkEndian`]: type.NetworkEndian.html
[`NativeEndian`]: type.NativeEndian.html
[`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
[`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
*/
#![deny(missing_docs)]
#![cfg_attr(not(feature = "std"), no_std)]
use core::{
convert::TryInto, fmt::Debug, hash::Hash, ptr::copy_nonoverlapping, slice,
};
#[cfg(feature = "std")]
pub use crate::io::{ReadBytesExt, WriteBytesExt};
#[cfg(feature = "std")]
mod io;
#[inline]
fn extend_sign(val: u64, nbytes: usize) -> i64 {
let shift = (8 - nbytes) * 8;
(val << shift) as i64 >> shift
}
#[inline]
fn extend_sign128(val: u128, nbytes: usize) -> i128 {
let shift = (16 - nbytes) * 8;
(val << shift) as i128 >> shift
}
#[inline]
fn unextend_sign(val: i64, nbytes: usize) -> u64 {
let shift = (8 - nbytes) * 8;
(val << shift) as u64 >> shift
}
#[inline]
fn unextend_sign128(val: i128, nbytes: usize) -> u128 {
let shift = (16 - nbytes) * 8;
(val << shift) as u128 >> shift
}
#[inline]
fn pack_size(n: u64) -> usize {
if n < 1 << 8 {
1
} else if n < 1 << 16 {
2
} else if n < 1 << 24 {
3
} else if n < 1 << 32 {
4
} else if n < 1 << 40 {
5
} else if n < 1 << 48 {
6
} else if n < 1 << 56 {
7
} else {
8
}
}
#[inline]
fn pack_size128(n: u128) -> usize {
if n < 1 << 8 {
1
} else if n < 1 << 16 {
2
} else if n < 1 << 24 {
3
} else if n < 1 << 32 {
4
} else if n < 1 << 40 {
5
} else if n < 1 << 48 {
6
} else if n < 1 << 56 {
7
} else if n < 1 << 64 {
8
} else if n < 1 << 72 {
9
} else if n < 1 << 80 {
10
} else if n < 1 << 88 {
11
} else if n < 1 << 96 {
12
} else if n < 1 << 104 {
13
} else if n < 1 << 112 {
14
} else if n < 1 << 120 {
15
} else {
16
}
}
mod private {
/// Sealed stops crates other than byteorder from implementing any traits
/// that use it.
pub trait Sealed {}
impl Sealed for super::LittleEndian {}
impl Sealed for super::BigEndian {}
}
/// `ByteOrder` describes types that can serialize integers as bytes.
///
/// Note that `Self` does not appear anywhere in this trait's definition!
/// Therefore, in order to use it, you'll need to use syntax like
/// `T::read_u16(&[0, 1])` where `T` implements `ByteOrder`.
///
/// This crate provides two types that implement `ByteOrder`: [`BigEndian`]
/// and [`LittleEndian`].
/// This trait is sealed and cannot be implemented for callers to avoid
/// breaking backwards compatibility when adding new derived traits.
///
/// # Examples
///
/// Write and read `u32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 4];
/// LittleEndian::write_u32(&mut buf, 1_000_000);
/// assert_eq!(1_000_000, LittleEndian::read_u32(&buf));
/// ```
///
/// Write and read `i16` numbers in big endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, BigEndian};
///
/// let mut buf = [0; 2];
/// BigEndian::write_i16(&mut buf, -5_000);
/// assert_eq!(-5_000, BigEndian::read_i16(&buf));
/// ```
///
/// [`BigEndian`]: enum.BigEndian.html
/// [`LittleEndian`]: enum.LittleEndian.html
pub trait ByteOrder:
Clone
+ Copy
+ Debug
+ Default
+ Eq
+ Hash
+ Ord
+ PartialEq
+ PartialOrd
+ private::Sealed
{
/// Reads an unsigned 16 bit integer from `buf`.
///
/// # Panics
///
/// Panics when `buf.len() < 2`.
fn read_u16(buf: &[u8]) -> u16;
/// Reads an unsigned 24 bit integer from `buf`, stored in u32.
///
/// # Panics
///
/// Panics when `buf.len() < 3`.
///
/// # Examples
///
/// Write and read 24 bit `u32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 3];
/// LittleEndian::write_u24(&mut buf, 1_000_000);
/// assert_eq!(1_000_000, LittleEndian::read_u24(&buf));
/// ```
fn read_u24(buf: &[u8]) -> u32 {
Self::read_uint(buf, 3) as u32
}
/// Reads an unsigned 32 bit integer from `buf`.
///
/// # Panics
///
/// Panics when `buf.len() < 4`.
///
/// # Examples
///
/// Write and read `u32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 4];
/// LittleEndian::write_u32(&mut buf, 1_000_000);
/// assert_eq!(1_000_000, LittleEndian::read_u32(&buf));
/// ```
fn read_u32(buf: &[u8]) -> u32;
/// Reads an unsigned 48 bit integer from `buf`, stored in u64.
///
/// # Panics
///
/// Panics when `buf.len() < 6`.
///
/// # Examples
///
/// Write and read 48 bit `u64` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 6];
/// LittleEndian::write_u48(&mut buf, 1_000_000_000_000);
/// assert_eq!(1_000_000_000_000, LittleEndian::read_u48(&buf));
/// ```
fn read_u48(buf: &[u8]) -> u64 {
Self::read_uint(buf, 6) as u64
}
/// Reads an unsigned 64 bit integer from `buf`.
///
/// # Panics
///
/// Panics when `buf.len() < 8`.
///
/// # Examples
///
/// Write and read `u64` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 8];
/// LittleEndian::write_u64(&mut buf, 1_000_000);
/// assert_eq!(1_000_000, LittleEndian::read_u64(&buf));
/// ```
fn read_u64(buf: &[u8]) -> u64;
/// Reads an unsigned 128 bit integer from `buf`.
///
/// # Panics
///
/// Panics when `buf.len() < 16`.
///
/// # Examples
///
/// Write and read `u128` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 16];
/// LittleEndian::write_u128(&mut buf, 1_000_000);
/// assert_eq!(1_000_000, LittleEndian::read_u128(&buf));
/// ```
fn read_u128(buf: &[u8]) -> u128;
/// Reads an unsigned n-bytes integer from `buf`.
///
/// # Panics
///
/// Panics when `nbytes < 1` or `nbytes > 8` or
/// `buf.len() < nbytes`
///
/// # Examples
///
/// Write and read an n-byte number in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 3];
/// LittleEndian::write_uint(&mut buf, 1_000_000, 3);
/// assert_eq!(1_000_000, LittleEndian::read_uint(&buf, 3));
/// ```
fn read_uint(buf: &[u8], nbytes: usize) -> u64;
/// Reads an unsigned n-bytes integer from `buf`.
///
/// # Panics
///
/// Panics when `nbytes < 1` or `nbytes > 16` or
/// `buf.len() < nbytes`
///
/// # Examples
///
/// Write and read an n-byte number in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 3];
/// LittleEndian::write_uint128(&mut buf, 1_000_000, 3);
/// assert_eq!(1_000_000, LittleEndian::read_uint128(&buf, 3));
/// ```
fn read_uint128(buf: &[u8], nbytes: usize) -> u128;
/// Writes an unsigned 16 bit integer `n` to `buf`.
///
/// # Panics
///
/// Panics when `buf.len() < 2`.
///
/// # Examples
///
/// Write and read `u16` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 2];
/// LittleEndian::write_u16(&mut buf, 1_000);
/// assert_eq!(1_000, LittleEndian::read_u16(&buf));
/// ```
fn write_u16(buf: &mut [u8], n: u16);
/// Writes an unsigned 24 bit integer `n` to `buf`, stored in u32.
///
/// # Panics
///
/// Panics when `buf.len() < 3`.
///
/// # Examples
///
/// Write and read 24 bit `u32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 3];
/// LittleEndian::write_u24(&mut buf, 1_000_000);
/// assert_eq!(1_000_000, LittleEndian::read_u24(&buf));
/// ```
fn write_u24(buf: &mut [u8], n: u32) {
Self::write_uint(buf, n as u64, 3)
}
/// Writes an unsigned 32 bit integer `n` to `buf`.
///
/// # Panics
///
/// Panics when `buf.len() < 4`.
///
/// # Examples
///
/// Write and read `u32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 4];
/// LittleEndian::write_u32(&mut buf, 1_000_000);
/// assert_eq!(1_000_000, LittleEndian::read_u32(&buf));
/// ```
fn write_u32(buf: &mut [u8], n: u32);
/// Writes an unsigned 48 bit integer `n` to `buf`, stored in u64.
///
/// # Panics
///
/// Panics when `buf.len() < 6`.
///
/// # Examples
///
/// Write and read 48 bit `u64` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 6];
/// LittleEndian::write_u48(&mut buf, 1_000_000_000_000);
/// assert_eq!(1_000_000_000_000, LittleEndian::read_u48(&buf));
/// ```
fn write_u48(buf: &mut [u8], n: u64) {
Self::write_uint(buf, n as u64, 6)
}
/// Writes an unsigned 64 bit integer `n` to `buf`.
///
/// # Panics
///
/// Panics when `buf.len() < 8`.
///
/// # Examples
///
/// Write and read `u64` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 8];
/// LittleEndian::write_u64(&mut buf, 1_000_000);
/// assert_eq!(1_000_000, LittleEndian::read_u64(&buf));
/// ```
fn write_u64(buf: &mut [u8], n: u64);
/// Writes an unsigned 128 bit integer `n` to `buf`.
///
/// # Panics
///
/// Panics when `buf.len() < 16`.
///
/// # Examples
///
/// Write and read `u128` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 16];
/// LittleEndian::write_u128(&mut buf, 1_000_000);
/// assert_eq!(1_000_000, LittleEndian::read_u128(&buf));
/// ```
fn write_u128(buf: &mut [u8], n: u128);
/// Writes an unsigned integer `n` to `buf` using only `nbytes`.
///
/// # Panics
///
/// If `n` is not representable in `nbytes`, or if `nbytes` is `> 8`, then
/// this method panics.
///
/// # Examples
///
/// Write and read an n-byte number in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 3];
/// LittleEndian::write_uint(&mut buf, 1_000_000, 3);
/// assert_eq!(1_000_000, LittleEndian::read_uint(&buf, 3));
/// ```
fn write_uint(buf: &mut [u8], n: u64, nbytes: usize);
/// Writes an unsigned integer `n` to `buf` using only `nbytes`.
///
/// # Panics
///
/// If `n` is not representable in `nbytes`, or if `nbytes` is `> 16`, then
/// this method panics.
///
/// # Examples
///
/// Write and read an n-byte number in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 3];
/// LittleEndian::write_uint128(&mut buf, 1_000_000, 3);
/// assert_eq!(1_000_000, LittleEndian::read_uint128(&buf, 3));
/// ```
fn write_uint128(buf: &mut [u8], n: u128, nbytes: usize);
/// Reads a signed 16 bit integer from `buf`.
///
/// # Panics
///
/// Panics when `buf.len() < 2`.
///
/// # Examples
///
/// Write and read `i16` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 2];
/// LittleEndian::write_i16(&mut buf, -1_000);
/// assert_eq!(-1_000, LittleEndian::read_i16(&buf));
/// ```
#[inline]
fn read_i16(buf: &[u8]) -> i16 {
Self::read_u16(buf) as i16
}
/// Reads a signed 24 bit integer from `buf`, stored in i32.
///
/// # Panics
///
/// Panics when `buf.len() < 3`.
///
/// # Examples
///
/// Write and read 24 bit `i32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 3];
/// LittleEndian::write_i24(&mut buf, -1_000_000);
/// assert_eq!(-1_000_000, LittleEndian::read_i24(&buf));
/// ```
#[inline]
fn read_i24(buf: &[u8]) -> i32 {
Self::read_int(buf, 3) as i32
}
/// Reads a signed 32 bit integer from `buf`.
///
/// # Panics
///
/// Panics when `buf.len() < 4`.
///
/// # Examples
///
/// Write and read `i32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 4];
/// LittleEndian::write_i32(&mut buf, -1_000_000);
/// assert_eq!(-1_000_000, LittleEndian::read_i32(&buf));
/// ```
#[inline]
fn read_i32(buf: &[u8]) -> i32 {
Self::read_u32(buf) as i32
}
/// Reads a signed 48 bit integer from `buf`, stored in i64.
///
/// # Panics
///
/// Panics when `buf.len() < 6`.
///
/// # Examples
///
/// Write and read 48 bit `i64` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 6];
/// LittleEndian::write_i48(&mut buf, -1_000_000_000_000);
/// assert_eq!(-1_000_000_000_000, LittleEndian::read_i48(&buf));
/// ```
#[inline]
fn read_i48(buf: &[u8]) -> i64 {
Self::read_int(buf, 6) as i64
}
/// Reads a signed 64 bit integer from `buf`.
///
/// # Panics
///
/// Panics when `buf.len() < 8`.
///
/// # Examples
///
/// Write and read `i64` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 8];
/// LittleEndian::write_i64(&mut buf, -1_000_000_000);
/// assert_eq!(-1_000_000_000, LittleEndian::read_i64(&buf));
/// ```
#[inline]
fn read_i64(buf: &[u8]) -> i64 {
Self::read_u64(buf) as i64
}
/// Reads a signed 128 bit integer from `buf`.
///
/// # Panics
///
/// Panics when `buf.len() < 16`.
///
/// # Examples
///
/// Write and read `i128` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 16];
/// LittleEndian::write_i128(&mut buf, -1_000_000_000);
/// assert_eq!(-1_000_000_000, LittleEndian::read_i128(&buf));
/// ```
#[inline]
fn read_i128(buf: &[u8]) -> i128 {
Self::read_u128(buf) as i128
}
/// Reads a signed n-bytes integer from `buf`.
///
/// # Panics
///
/// Panics when `nbytes < 1` or `nbytes > 8` or
/// `buf.len() < nbytes`
///
/// # Examples
///
/// Write and read n-length signed numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 3];
/// LittleEndian::write_int(&mut buf, -1_000, 3);
/// assert_eq!(-1_000, LittleEndian::read_int(&buf, 3));
/// ```
#[inline]
fn read_int(buf: &[u8], nbytes: usize) -> i64 {
extend_sign(Self::read_uint(buf, nbytes), nbytes)
}
/// Reads a signed n-bytes integer from `buf`.
///
/// # Panics
///
/// Panics when `nbytes < 1` or `nbytes > 16` or
/// `buf.len() < nbytes`
///
/// # Examples
///
/// Write and read n-length signed numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 3];
/// LittleEndian::write_int128(&mut buf, -1_000, 3);
/// assert_eq!(-1_000, LittleEndian::read_int128(&buf, 3));
/// ```
#[inline]
fn read_int128(buf: &[u8], nbytes: usize) -> i128 {
extend_sign128(Self::read_uint128(buf, nbytes), nbytes)
}
/// Reads a IEEE754 single-precision (4 bytes) floating point number.
///
/// # Panics
///
/// Panics when `buf.len() < 4`.
///
/// # Examples
///
/// Write and read `f32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let e = 2.71828;
/// let mut buf = [0; 4];
/// LittleEndian::write_f32(&mut buf, e);
/// assert_eq!(e, LittleEndian::read_f32(&buf));
/// ```
#[inline]
fn read_f32(buf: &[u8]) -> f32 {
f32::from_bits(Self::read_u32(buf))
}
/// Reads a IEEE754 double-precision (8 bytes) floating point number.
///
/// # Panics
///
/// Panics when `buf.len() < 8`.
///
/// # Examples
///
/// Write and read `f64` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let phi = 1.6180339887;
/// let mut buf = [0; 8];
/// LittleEndian::write_f64(&mut buf, phi);
/// assert_eq!(phi, LittleEndian::read_f64(&buf));
/// ```
#[inline]
fn read_f64(buf: &[u8]) -> f64 {
f64::from_bits(Self::read_u64(buf))
}
/// Writes a signed 16 bit integer `n` to `buf`.
///
/// # Panics
///
/// Panics when `buf.len() < 2`.
///
/// # Examples
///
/// Write and read `i16` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 2];
/// LittleEndian::write_i16(&mut buf, -1_000);
/// assert_eq!(-1_000, LittleEndian::read_i16(&buf));
/// ```
#[inline]
fn write_i16(buf: &mut [u8], n: i16) {
Self::write_u16(buf, n as u16)
}
/// Writes a signed 24 bit integer `n` to `buf`, stored in i32.
///
/// # Panics
///
/// Panics when `buf.len() < 3`.
///
/// # Examples
///
/// Write and read 24 bit `i32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 3];
/// LittleEndian::write_i24(&mut buf, -1_000_000);
/// assert_eq!(-1_000_000, LittleEndian::read_i24(&buf));
/// ```
#[inline]
fn write_i24(buf: &mut [u8], n: i32) {
Self::write_int(buf, n as i64, 3)
}
/// Writes a signed 32 bit integer `n` to `buf`.
///
/// # Panics
///
/// Panics when `buf.len() < 4`.
///
/// # Examples
///
/// Write and read `i32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 4];
/// LittleEndian::write_i32(&mut buf, -1_000_000);
/// assert_eq!(-1_000_000, LittleEndian::read_i32(&buf));
/// ```
#[inline]
fn write_i32(buf: &mut [u8], n: i32) {
Self::write_u32(buf, n as u32)
}
/// Writes a signed 48 bit integer `n` to `buf`, stored in i64.
///
/// # Panics
///
/// Panics when `buf.len() < 6`.
///
/// # Examples
///
/// Write and read 48 bit `i64` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 6];
/// LittleEndian::write_i48(&mut buf, -1_000_000_000_000);
/// assert_eq!(-1_000_000_000_000, LittleEndian::read_i48(&buf));
/// ```
#[inline]
fn write_i48(buf: &mut [u8], n: i64) {
Self::write_int(buf, n as i64, 6)
}
/// Writes a signed 64 bit integer `n` to `buf`.
///
/// # Panics
///
/// Panics when `buf.len() < 8`.
///
/// # Examples
///
/// Write and read `i64` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 8];
/// LittleEndian::write_i64(&mut buf, -1_000_000_000);
/// assert_eq!(-1_000_000_000, LittleEndian::read_i64(&buf));
/// ```
#[inline]
fn write_i64(buf: &mut [u8], n: i64) {
Self::write_u64(buf, n as u64)
}
/// Writes a signed 128 bit integer `n` to `buf`.
///
/// # Panics
///
/// Panics when `buf.len() < 16`.
///
/// # Examples
///
/// Write and read n-byte `i128` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 16];
/// LittleEndian::write_i128(&mut buf, -1_000_000_000);
/// assert_eq!(-1_000_000_000, LittleEndian::read_i128(&buf));
/// ```
#[inline]
fn write_i128(buf: &mut [u8], n: i128) {
Self::write_u128(buf, n as u128)
}
/// Writes a signed integer `n` to `buf` using only `nbytes`.
///
/// # Panics
///
/// If `n` is not representable in `nbytes`, or if `nbytes` is `> 8`, then
/// this method panics.
///
/// # Examples
///
/// Write and read an n-byte number in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 3];
/// LittleEndian::write_int(&mut buf, -1_000, 3);
/// assert_eq!(-1_000, LittleEndian::read_int(&buf, 3));
/// ```
#[inline]
fn write_int(buf: &mut [u8], n: i64, nbytes: usize) {
Self::write_uint(buf, unextend_sign(n, nbytes), nbytes)
}
/// Writes a signed integer `n` to `buf` using only `nbytes`.
///
/// # Panics
///
/// If `n` is not representable in `nbytes`, or if `nbytes` is `> 16`, then
/// this method panics.
///
/// # Examples
///
/// Write and read n-length signed numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 3];
/// LittleEndian::write_int128(&mut buf, -1_000, 3);
/// assert_eq!(-1_000, LittleEndian::read_int128(&buf, 3));
/// ```
#[inline]
fn write_int128(buf: &mut [u8], n: i128, nbytes: usize) {
Self::write_uint128(buf, unextend_sign128(n, nbytes), nbytes)
}
/// Writes a IEEE754 single-precision (4 bytes) floating point number.
///
/// # Panics
///
/// Panics when `buf.len() < 4`.
///
/// # Examples
///
/// Write and read `f32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let e = 2.71828;
/// let mut buf = [0; 4];
/// LittleEndian::write_f32(&mut buf, e);
/// assert_eq!(e, LittleEndian::read_f32(&buf));
/// ```
#[inline]
fn write_f32(buf: &mut [u8], n: f32) {
Self::write_u32(buf, n.to_bits())
}
/// Writes a IEEE754 double-precision (8 bytes) floating point number.
///
/// # Panics
///
/// Panics when `buf.len() < 8`.
///
/// # Examples
///
/// Write and read `f64` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let phi = 1.6180339887;
/// let mut buf = [0; 8];
/// LittleEndian::write_f64(&mut buf, phi);
/// assert_eq!(phi, LittleEndian::read_f64(&buf));
/// ```
#[inline]
fn write_f64(buf: &mut [u8], n: f64) {
Self::write_u64(buf, n.to_bits())
}
/// Reads unsigned 16 bit integers from `src` into `dst`.
///
/// # Panics
///
/// Panics when `src.len() != 2*dst.len()`.
///
/// # Examples
///
/// Write and read `u16` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 8];
/// let numbers_given = [1, 2, 0xf00f, 0xffee];
/// LittleEndian::write_u16_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0; 4];
/// LittleEndian::read_u16_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
fn read_u16_into(src: &[u8], dst: &mut [u16]);
/// Reads unsigned 32 bit integers from `src` into `dst`.
///
/// # Panics
///
/// Panics when `src.len() != 4*dst.len()`.
///
/// # Examples
///
/// Write and read `u32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 16];
/// let numbers_given = [1, 2, 0xf00f, 0xffee];
/// LittleEndian::write_u32_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0; 4];
/// LittleEndian::read_u32_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
fn read_u32_into(src: &[u8], dst: &mut [u32]);
/// Reads unsigned 64 bit integers from `src` into `dst`.
///
/// # Panics
///
/// Panics when `src.len() != 8*dst.len()`.
///
/// # Examples
///
/// Write and read `u64` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 32];
/// let numbers_given = [1, 2, 0xf00f, 0xffee];
/// LittleEndian::write_u64_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0; 4];
/// LittleEndian::read_u64_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
fn read_u64_into(src: &[u8], dst: &mut [u64]);
/// Reads unsigned 128 bit integers from `src` into `dst`.
///
/// # Panics
///
/// Panics when `src.len() != 16*dst.len()`.
///
/// # Examples
///
/// Write and read `u128` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 64];
/// let numbers_given = [1, 2, 0xf00f, 0xffee];
/// LittleEndian::write_u128_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0; 4];
/// LittleEndian::read_u128_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
fn read_u128_into(src: &[u8], dst: &mut [u128]);
/// Reads signed 16 bit integers from `src` to `dst`.
///
/// # Panics
///
/// Panics when `buf.len() != 2*dst.len()`.
///
/// # Examples
///
/// Write and read `i16` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 8];
/// let numbers_given = [1, 2, 0x0f, 0xee];
/// LittleEndian::write_i16_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0; 4];
/// LittleEndian::read_i16_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
#[inline]
fn read_i16_into(src: &[u8], dst: &mut [i16]) {
let dst = unsafe {
slice::from_raw_parts_mut(dst.as_mut_ptr() as *mut u16, dst.len())
};
Self::read_u16_into(src, dst)
}
/// Reads signed 32 bit integers from `src` into `dst`.
///
/// # Panics
///
/// Panics when `src.len() != 4*dst.len()`.
///
/// # Examples
///
/// Write and read `i32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 16];
/// let numbers_given = [1, 2, 0xf00f, 0xffee];
/// LittleEndian::write_i32_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0; 4];
/// LittleEndian::read_i32_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
#[inline]
fn read_i32_into(src: &[u8], dst: &mut [i32]) {
let dst = unsafe {
slice::from_raw_parts_mut(dst.as_mut_ptr() as *mut u32, dst.len())
};
Self::read_u32_into(src, dst);
}
/// Reads signed 64 bit integers from `src` into `dst`.
///
/// # Panics
///
/// Panics when `src.len() != 8*dst.len()`.
///
/// # Examples
///
/// Write and read `i64` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 32];
/// let numbers_given = [1, 2, 0xf00f, 0xffee];
/// LittleEndian::write_i64_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0; 4];
/// LittleEndian::read_i64_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
#[inline]
fn read_i64_into(src: &[u8], dst: &mut [i64]) {
let dst = unsafe {
slice::from_raw_parts_mut(dst.as_mut_ptr() as *mut u64, dst.len())
};
Self::read_u64_into(src, dst);
}
/// Reads signed 128 bit integers from `src` into `dst`.
///
/// # Panics
///
/// Panics when `src.len() != 16*dst.len()`.
///
/// # Examples
///
/// Write and read `i128` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 64];
/// let numbers_given = [1, 2, 0xf00f, 0xffee];
/// LittleEndian::write_i128_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0; 4];
/// LittleEndian::read_i128_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
#[inline]
fn read_i128_into(src: &[u8], dst: &mut [i128]) {
let dst = unsafe {
slice::from_raw_parts_mut(dst.as_mut_ptr() as *mut u128, dst.len())
};
Self::read_u128_into(src, dst);
}
/// Reads IEEE754 single-precision (4 bytes) floating point numbers from
/// `src` into `dst`.
///
/// # Panics
///
/// Panics when `src.len() != 4*dst.len()`.
///
/// # Examples
///
/// Write and read `f32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 16];
/// let numbers_given = [1.0, 2.0, 31.312e31, -11.32e19];
/// LittleEndian::write_f32_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0.0; 4];
/// LittleEndian::read_f32_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
#[inline]
fn read_f32_into(src: &[u8], dst: &mut [f32]) {
let dst = unsafe {
slice::from_raw_parts_mut(dst.as_mut_ptr() as *mut u32, dst.len())
};
Self::read_u32_into(src, dst);
}
/// **DEPRECATED**.
///
/// This method is deprecated. Use `read_f32_into` instead.
/// Reads IEEE754 single-precision (4 bytes) floating point numbers from
/// `src` into `dst`.
///
/// # Panics
///
/// Panics when `src.len() != 4*dst.len()`.
///
/// # Examples
///
/// Write and read `f32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 16];
/// let numbers_given = [1.0, 2.0, 31.312e31, -11.32e19];
/// LittleEndian::write_f32_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0.0; 4];
/// LittleEndian::read_f32_into_unchecked(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
#[inline]
#[deprecated(since = "1.3.0", note = "please use `read_f32_into` instead")]
fn read_f32_into_unchecked(src: &[u8], dst: &mut [f32]) {
Self::read_f32_into(src, dst);
}
/// Reads IEEE754 single-precision (4 bytes) floating point numbers from
/// `src` into `dst`.
///
/// # Panics
///
/// Panics when `src.len() != 8*dst.len()`.
///
/// # Examples
///
/// Write and read `f64` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 32];
/// let numbers_given = [1.0, 2.0, 31.312e211, -11.32e91];
/// LittleEndian::write_f64_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0.0; 4];
/// LittleEndian::read_f64_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
#[inline]
fn read_f64_into(src: &[u8], dst: &mut [f64]) {
let dst = unsafe {
slice::from_raw_parts_mut(dst.as_mut_ptr() as *mut u64, dst.len())
};
Self::read_u64_into(src, dst);
}
/// **DEPRECATED**.
///
/// This method is deprecated. Use `read_f64_into` instead.
///
/// Reads IEEE754 single-precision (4 bytes) floating point numbers from
/// `src` into `dst`.
///
/// # Panics
///
/// Panics when `src.len() != 8*dst.len()`.
///
/// # Examples
///
/// Write and read `f64` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 32];
/// let numbers_given = [1.0, 2.0, 31.312e211, -11.32e91];
/// LittleEndian::write_f64_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0.0; 4];
/// LittleEndian::read_f64_into_unchecked(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
#[inline]
#[deprecated(since = "1.3.0", note = "please use `read_f64_into` instead")]
fn read_f64_into_unchecked(src: &[u8], dst: &mut [f64]) {
Self::read_f64_into(src, dst);
}
/// Writes unsigned 16 bit integers from `src` into `dst`.
///
/// # Panics
///
/// Panics when `dst.len() != 2*src.len()`.
///
/// # Examples
///
/// Write and read `u16` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 8];
/// let numbers_given = [1, 2, 0xf00f, 0xffee];
/// LittleEndian::write_u16_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0; 4];
/// LittleEndian::read_u16_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
fn write_u16_into(src: &[u16], dst: &mut [u8]);
/// Writes unsigned 32 bit integers from `src` into `dst`.
///
/// # Panics
///
/// Panics when `dst.len() != 4*src.len()`.
///
/// # Examples
///
/// Write and read `u32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 16];
/// let numbers_given = [1, 2, 0xf00f, 0xffee];
/// LittleEndian::write_u32_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0; 4];
/// LittleEndian::read_u32_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
fn write_u32_into(src: &[u32], dst: &mut [u8]);
/// Writes unsigned 64 bit integers from `src` into `dst`.
///
/// # Panics
///
/// Panics when `dst.len() != 8*src.len()`.
///
/// # Examples
///
/// Write and read `u64` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 32];
/// let numbers_given = [1, 2, 0xf00f, 0xffee];
/// LittleEndian::write_u64_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0; 4];
/// LittleEndian::read_u64_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
fn write_u64_into(src: &[u64], dst: &mut [u8]);
/// Writes unsigned 128 bit integers from `src` into `dst`.
///
/// # Panics
///
/// Panics when `dst.len() != 16*src.len()`.
///
/// # Examples
///
/// Write and read `u128` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 64];
/// let numbers_given = [1, 2, 0xf00f, 0xffee];
/// LittleEndian::write_u128_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0; 4];
/// LittleEndian::read_u128_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
fn write_u128_into(src: &[u128], dst: &mut [u8]);
/// Writes signed 8 bit integers from `src` into `dst`.
///
/// Note that since each `i8` is a single byte, no byte order conversions
/// are used. This method is included because it provides a safe, simple
/// way for the caller to write from a `&[i8]` buffer. (Without this
/// method, the caller would have to either use `unsafe` code or convert
/// each byte to `u8` individually.)
///
/// # Panics
///
/// Panics when `buf.len() != src.len()`.
///
/// # Examples
///
/// Write and read `i8` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian, ReadBytesExt};
///
/// let mut bytes = [0; 4];
/// let numbers_given = [1, 2, 0xf, 0xe];
/// LittleEndian::write_i8_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0; 4];
/// bytes.as_ref().read_i8_into(&mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
fn write_i8_into(src: &[i8], dst: &mut [u8]) {
let src = unsafe {
slice::from_raw_parts(src.as_ptr() as *const u8, src.len())
};
dst.copy_from_slice(src);
}
/// Writes signed 16 bit integers from `src` into `dst`.
///
/// # Panics
///
/// Panics when `buf.len() != 2*src.len()`.
///
/// # Examples
///
/// Write and read `i16` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 8];
/// let numbers_given = [1, 2, 0x0f, 0xee];
/// LittleEndian::write_i16_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0; 4];
/// LittleEndian::read_i16_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
fn write_i16_into(src: &[i16], dst: &mut [u8]) {
let src = unsafe {
slice::from_raw_parts(src.as_ptr() as *const u16, src.len())
};
Self::write_u16_into(src, dst);
}
/// Writes signed 32 bit integers from `src` into `dst`.
///
/// # Panics
///
/// Panics when `dst.len() != 4*src.len()`.
///
/// # Examples
///
/// Write and read `i32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 16];
/// let numbers_given = [1, 2, 0xf00f, 0xffee];
/// LittleEndian::write_i32_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0; 4];
/// LittleEndian::read_i32_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
fn write_i32_into(src: &[i32], dst: &mut [u8]) {
let src = unsafe {
slice::from_raw_parts(src.as_ptr() as *const u32, src.len())
};
Self::write_u32_into(src, dst);
}
/// Writes signed 64 bit integers from `src` into `dst`.
///
/// # Panics
///
/// Panics when `dst.len() != 8*src.len()`.
///
/// # Examples
///
/// Write and read `i64` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 32];
/// let numbers_given = [1, 2, 0xf00f, 0xffee];
/// LittleEndian::write_i64_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0; 4];
/// LittleEndian::read_i64_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
fn write_i64_into(src: &[i64], dst: &mut [u8]) {
let src = unsafe {
slice::from_raw_parts(src.as_ptr() as *const u64, src.len())
};
Self::write_u64_into(src, dst);
}
/// Writes signed 128 bit integers from `src` into `dst`.
///
/// # Panics
///
/// Panics when `dst.len() != 16*src.len()`.
///
/// # Examples
///
/// Write and read `i128` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 64];
/// let numbers_given = [1, 2, 0xf00f, 0xffee];
/// LittleEndian::write_i128_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0; 4];
/// LittleEndian::read_i128_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
fn write_i128_into(src: &[i128], dst: &mut [u8]) {
let src = unsafe {
slice::from_raw_parts(src.as_ptr() as *const u128, src.len())
};
Self::write_u128_into(src, dst);
}
/// Writes IEEE754 single-precision (4 bytes) floating point numbers from
/// `src` into `dst`.
///
/// # Panics
///
/// Panics when `src.len() != 4*dst.len()`.
///
/// # Examples
///
/// Write and read `f32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 16];
/// let numbers_given = [1.0, 2.0, 31.312e31, -11.32e19];
/// LittleEndian::write_f32_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0.0; 4];
/// LittleEndian::read_f32_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
fn write_f32_into(src: &[f32], dst: &mut [u8]) {
let src = unsafe {
slice::from_raw_parts(src.as_ptr() as *const u32, src.len())
};
Self::write_u32_into(src, dst);
}
/// Writes IEEE754 double-precision (8 bytes) floating point numbers from
/// `src` into `dst`.
///
/// # Panics
///
/// Panics when `src.len() != 8*dst.len()`.
///
/// # Examples
///
/// Write and read `f64` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut bytes = [0; 32];
/// let numbers_given = [1.0, 2.0, 31.312e211, -11.32e91];
/// LittleEndian::write_f64_into(&numbers_given, &mut bytes);
///
/// let mut numbers_got = [0.0; 4];
/// LittleEndian::read_f64_into(&bytes, &mut numbers_got);
/// assert_eq!(numbers_given, numbers_got);
/// ```
fn write_f64_into(src: &[f64], dst: &mut [u8]) {
let src = unsafe {
slice::from_raw_parts(src.as_ptr() as *const u64, src.len())
};
Self::write_u64_into(src, dst);
}
/// Converts the given slice of unsigned 16 bit integers to a particular
/// endianness.
///
/// If the endianness matches the endianness of the host platform, then
/// this is a no-op.
///
/// # Examples
///
/// Convert the host platform's endianness to big-endian:
///
/// ```rust
/// use byteorder::{ByteOrder, BigEndian};
///
/// let mut numbers = [5, 65000];
/// BigEndian::from_slice_u16(&mut numbers);
/// assert_eq!(numbers, [5u16.to_be(), 65000u16.to_be()]);
/// ```
fn from_slice_u16(numbers: &mut [u16]);
/// Converts the given slice of unsigned 32 bit integers to a particular
/// endianness.
///
/// If the endianness matches the endianness of the host platform, then
/// this is a no-op.
///
/// # Examples
///
/// Convert the host platform's endianness to big-endian:
///
/// ```rust
/// use byteorder::{ByteOrder, BigEndian};
///
/// let mut numbers = [5, 65000];
/// BigEndian::from_slice_u32(&mut numbers);
/// assert_eq!(numbers, [5u32.to_be(), 65000u32.to_be()]);
/// ```
fn from_slice_u32(numbers: &mut [u32]);
/// Converts the given slice of unsigned 64 bit integers to a particular
/// endianness.
///
/// If the endianness matches the endianness of the host platform, then
/// this is a no-op.
///
/// # Examples
///
/// Convert the host platform's endianness to big-endian:
///
/// ```rust
/// use byteorder::{ByteOrder, BigEndian};
///
/// let mut numbers = [5, 65000];
/// BigEndian::from_slice_u64(&mut numbers);
/// assert_eq!(numbers, [5u64.to_be(), 65000u64.to_be()]);
/// ```
fn from_slice_u64(numbers: &mut [u64]);
/// Converts the given slice of unsigned 128 bit integers to a particular
/// endianness.
///
/// If the endianness matches the endianness of the host platform, then
/// this is a no-op.
///
/// # Examples
///
/// Convert the host platform's endianness to big-endian:
///
/// ```rust
/// use byteorder::{ByteOrder, BigEndian};
///
/// let mut numbers = [5, 65000];
/// BigEndian::from_slice_u128(&mut numbers);
/// assert_eq!(numbers, [5u128.to_be(), 65000u128.to_be()]);
/// ```
fn from_slice_u128(numbers: &mut [u128]);
/// Converts the given slice of signed 16 bit integers to a particular
/// endianness.
///
/// If the endianness matches the endianness of the host platform, then
/// this is a no-op.
///
/// # Examples
///
/// Convert the host platform's endianness to big-endian:
///
/// ```rust
/// use byteorder::{ByteOrder, BigEndian};
///
/// let mut numbers = [5, 6500];
/// BigEndian::from_slice_i16(&mut numbers);
/// assert_eq!(numbers, [5i16.to_be(), 6500i16.to_be()]);
/// ```
#[inline]
fn from_slice_i16(src: &mut [i16]) {
let src = unsafe {
slice::from_raw_parts_mut(src.as_mut_ptr() as *mut u16, src.len())
};
Self::from_slice_u16(src);
}
/// Converts the given slice of signed 32 bit integers to a particular
/// endianness.
///
/// If the endianness matches the endianness of the host platform, then
/// this is a no-op.
///
/// # Examples
///
/// Convert the host platform's endianness to big-endian:
///
/// ```rust
/// use byteorder::{ByteOrder, BigEndian};
///
/// let mut numbers = [5, 65000];
/// BigEndian::from_slice_i32(&mut numbers);
/// assert_eq!(numbers, [5i32.to_be(), 65000i32.to_be()]);
/// ```
#[inline]
fn from_slice_i32(src: &mut [i32]) {
let src = unsafe {
slice::from_raw_parts_mut(src.as_mut_ptr() as *mut u32, src.len())
};
Self::from_slice_u32(src);
}
/// Converts the given slice of signed 64 bit integers to a particular
/// endianness.
///
/// If the endianness matches the endianness of the host platform, then
/// this is a no-op.
///
/// # Examples
///
/// Convert the host platform's endianness to big-endian:
///
/// ```rust
/// use byteorder::{ByteOrder, BigEndian};
///
/// let mut numbers = [5, 65000];
/// BigEndian::from_slice_i64(&mut numbers);
/// assert_eq!(numbers, [5i64.to_be(), 65000i64.to_be()]);
/// ```
#[inline]
fn from_slice_i64(src: &mut [i64]) {
let src = unsafe {
slice::from_raw_parts_mut(src.as_mut_ptr() as *mut u64, src.len())
};
Self::from_slice_u64(src);
}
/// Converts the given slice of signed 128 bit integers to a particular
/// endianness.
///
/// If the endianness matches the endianness of the host platform, then
/// this is a no-op.
///
/// # Examples
///
/// Convert the host platform's endianness to big-endian:
///
/// ```rust
/// use byteorder::{ByteOrder, BigEndian};
///
/// let mut numbers = [5, 65000];
/// BigEndian::from_slice_i128(&mut numbers);
/// assert_eq!(numbers, [5i128.to_be(), 65000i128.to_be()]);
/// ```
#[inline]
fn from_slice_i128(src: &mut [i128]) {
let src = unsafe {
slice::from_raw_parts_mut(src.as_mut_ptr() as *mut u128, src.len())
};
Self::from_slice_u128(src);
}
/// Converts the given slice of IEEE754 single-precision (4 bytes) floating
/// point numbers to a particular endianness.
///
/// If the endianness matches the endianness of the host platform, then
/// this is a no-op.
fn from_slice_f32(numbers: &mut [f32]);
/// Converts the given slice of IEEE754 double-precision (8 bytes) floating
/// point numbers to a particular endianness.
///
/// If the endianness matches the endianness of the host platform, then
/// this is a no-op.
fn from_slice_f64(numbers: &mut [f64]);
}
/// Defines big-endian serialization.
///
/// Note that this type has no value constructor. It is used purely at the
/// type level.
///
/// # Examples
///
/// Write and read `u32` numbers in big endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, BigEndian};
///
/// let mut buf = [0; 4];
/// BigEndian::write_u32(&mut buf, 1_000_000);
/// assert_eq!(1_000_000, BigEndian::read_u32(&buf));
/// ```
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum BigEndian {}
impl Default for BigEndian {
fn default() -> BigEndian {
panic!("BigEndian default")
}
}
/// A type alias for [`BigEndian`].
///
/// [`BigEndian`]: enum.BigEndian.html
pub type BE = BigEndian;
/// Defines little-endian serialization.
///
/// Note that this type has no value constructor. It is used purely at the
/// type level.
///
/// # Examples
///
/// Write and read `u32` numbers in little endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, LittleEndian};
///
/// let mut buf = [0; 4];
/// LittleEndian::write_u32(&mut buf, 1_000_000);
/// assert_eq!(1_000_000, LittleEndian::read_u32(&buf));
/// ```
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum LittleEndian {}
impl Default for LittleEndian {
fn default() -> LittleEndian {
panic!("LittleEndian default")
}
}
/// A type alias for [`LittleEndian`].
///
/// [`LittleEndian`]: enum.LittleEndian.html
pub type LE = LittleEndian;
/// Defines network byte order serialization.
///
/// Network byte order is defined by [RFC 1700][1] to be big-endian, and is
/// referred to in several protocol specifications. This type is an alias of
/// [`BigEndian`].
///
/// [1]: https://tools.ietf.org/html/rfc1700
///
/// Note that this type has no value constructor. It is used purely at the
/// type level.
///
/// # Examples
///
/// Write and read `i16` numbers in big endian order:
///
/// ```rust
/// use byteorder::{ByteOrder, NetworkEndian, BigEndian};
///
/// let mut buf = [0; 2];
/// BigEndian::write_i16(&mut buf, -5_000);
/// assert_eq!(-5_000, NetworkEndian::read_i16(&buf));
/// ```
///
/// [`BigEndian`]: enum.BigEndian.html
pub type NetworkEndian = BigEndian;
/// Defines system native-endian serialization.
///
/// Note that this type has no value constructor. It is used purely at the
/// type level.
///
/// On this platform, this is an alias for [`LittleEndian`].
///
/// [`LittleEndian`]: enum.LittleEndian.html
#[cfg(target_endian = "little")]
pub type NativeEndian = LittleEndian;
/// Defines system native-endian serialization.
///
/// Note that this type has no value constructor. It is used purely at the
/// type level.
///
/// On this platform, this is an alias for [`BigEndian`].
///
/// [`BigEndian`]: enum.BigEndian.html
#[cfg(target_endian = "big")]
pub type NativeEndian = BigEndian;
/// Copies $size bytes from a number $n to a &mut [u8] $dst. $ty represents the
/// numeric type of $n and $which must be either to_be or to_le, depending on
/// which endianness one wants to use when writing to $dst.
///
/// This macro is only safe to call when $ty is a numeric type and $size ==
/// size_of::<$ty>() and where $dst is a &mut [u8].
macro_rules! unsafe_write_num_bytes {
($ty:ty, $size:expr, $n:expr, $dst:expr, $which:ident) => {{
assert!($size <= $dst.len());
unsafe {
// N.B. https://github.com/rust-lang/rust/issues/22776
let bytes = *(&$n.$which() as *const _ as *const [u8; $size]);
copy_nonoverlapping((&bytes).as_ptr(), $dst.as_mut_ptr(), $size);
}
}};
}
/// Copies a &[u8] $src into a &mut [<numeric>] $dst for the endianness given
/// by $which (must be either to_be or to_le).
///
/// This macro is only safe to call when $src and $dst are &[u8] and &mut [u8],
/// respectively. The macro will panic if $src.len() != $size * $dst.len(),
/// where $size represents the size of the integers encoded in $src.
macro_rules! unsafe_read_slice {
($src:expr, $dst:expr, $size:expr, $which:ident) => {{
assert_eq!($src.len(), $size * $dst.len());
unsafe {
copy_nonoverlapping(
$src.as_ptr(),
$dst.as_mut_ptr() as *mut u8,
$src.len(),
);
}
for v in $dst.iter_mut() {
*v = v.$which();
}
}};
}
/// Copies a &[$ty] $src into a &mut [u8] $dst, where $ty must be a numeric
/// type. This panics if size_of::<$ty>() * $src.len() != $dst.len().
///
/// This macro is only safe to call when $src is a slice of numeric types and
/// $dst is a &mut [u8] and where $ty represents the type of the integers in
/// $src.
macro_rules! unsafe_write_slice_native {
($src:expr, $dst:expr, $ty:ty) => {{
let size = core::mem::size_of::<$ty>();
assert_eq!(size * $src.len(), $dst.len());
unsafe {
copy_nonoverlapping(
$src.as_ptr() as *const u8,
$dst.as_mut_ptr(),
$dst.len(),
);
}
}};
}
macro_rules! write_slice {
($src:expr, $dst:expr, $ty:ty, $size:expr, $write:expr) => {{
assert!($size == ::core::mem::size_of::<$ty>());
assert_eq!($size * $src.len(), $dst.len());
for (&n, chunk) in $src.iter().zip($dst.chunks_mut($size)) {
$write(chunk, n);
}
}};
}
impl ByteOrder for BigEndian {
#[inline]
fn read_u16(buf: &[u8]) -> u16 {
u16::from_be_bytes(buf[..2].try_into().unwrap())
}
#[inline]
fn read_u32(buf: &[u8]) -> u32 {
u32::from_be_bytes(buf[..4].try_into().unwrap())
}
#[inline]
fn read_u64(buf: &[u8]) -> u64 {
u64::from_be_bytes(buf[..8].try_into().unwrap())
}
#[inline]
fn read_u128(buf: &[u8]) -> u128 {
u128::from_be_bytes(buf[..16].try_into().unwrap())
}
#[inline]
fn read_uint(buf: &[u8], nbytes: usize) -> u64 {
assert!(1 <= nbytes && nbytes <= 8 && nbytes <= buf.len());
let mut out = 0u64;
let ptr_out = &mut out as *mut u64 as *mut u8;
unsafe {
copy_nonoverlapping(
buf.as_ptr(),
ptr_out.offset((8 - nbytes) as isize),
nbytes,
);
}
out.to_be()
}
#[inline]
fn read_uint128(buf: &[u8], nbytes: usize) -> u128 {
assert!(1 <= nbytes && nbytes <= 16 && nbytes <= buf.len());
let mut out: u128 = 0;
let ptr_out = &mut out as *mut u128 as *mut u8;
unsafe {
copy_nonoverlapping(
buf.as_ptr(),
ptr_out.offset((16 - nbytes) as isize),
nbytes,
);
}
out.to_be()
}
#[inline]
fn write_u16(buf: &mut [u8], n: u16) {
unsafe_write_num_bytes!(u16, 2, n, buf, to_be);
}
#[inline]
fn write_u32(buf: &mut [u8], n: u32) {
unsafe_write_num_bytes!(u32, 4, n, buf, to_be);
}
#[inline]
fn write_u64(buf: &mut [u8], n: u64) {
unsafe_write_num_bytes!(u64, 8, n, buf, to_be);
}
#[inline]
fn write_u128(buf: &mut [u8], n: u128) {
unsafe_write_num_bytes!(u128, 16, n, buf, to_be);
}
#[inline]
fn write_uint(buf: &mut [u8], n: u64, nbytes: usize) {
assert!(pack_size(n) <= nbytes && nbytes <= 8);
assert!(nbytes <= buf.len());
unsafe {
let bytes = *(&n.to_be() as *const u64 as *const [u8; 8]);
copy_nonoverlapping(
bytes.as_ptr().offset((8 - nbytes) as isize),
buf.as_mut_ptr(),
nbytes,
);
}
}
#[inline]
fn write_uint128(buf: &mut [u8], n: u128, nbytes: usize) {
assert!(pack_size128(n) <= nbytes && nbytes <= 16);
assert!(nbytes <= buf.len());
unsafe {
let bytes = *(&n.to_be() as *const u128 as *const [u8; 16]);
copy_nonoverlapping(
bytes.as_ptr().offset((16 - nbytes) as isize),
buf.as_mut_ptr(),
nbytes,
);
}
}
#[inline]
fn read_u16_into(src: &[u8], dst: &mut [u16]) {
unsafe_read_slice!(src, dst, 2, to_be);
}
#[inline]
fn read_u32_into(src: &[u8], dst: &mut [u32]) {
unsafe_read_slice!(src, dst, 4, to_be);
}
#[inline]
fn read_u64_into(src: &[u8], dst: &mut [u64]) {
unsafe_read_slice!(src, dst, 8, to_be);
}
#[inline]
fn read_u128_into(src: &[u8], dst: &mut [u128]) {
unsafe_read_slice!(src, dst, 16, to_be);
}
#[inline]
fn write_u16_into(src: &[u16], dst: &mut [u8]) {
if cfg!(target_endian = "big") {
unsafe_write_slice_native!(src, dst, u16);
} else {
write_slice!(src, dst, u16, 2, Self::write_u16);
}
}
#[inline]
fn write_u32_into(src: &[u32], dst: &mut [u8]) {
if cfg!(target_endian = "big") {
unsafe_write_slice_native!(src, dst, u32);
} else {
write_slice!(src, dst, u32, 4, Self::write_u32);
}
}
#[inline]
fn write_u64_into(src: &[u64], dst: &mut [u8]) {
if cfg!(target_endian = "big") {
unsafe_write_slice_native!(src, dst, u64);
} else {
write_slice!(src, dst, u64, 8, Self::write_u64);
}
}
#[inline]
fn write_u128_into(src: &[u128], dst: &mut [u8]) {
if cfg!(target_endian = "big") {
unsafe_write_slice_native!(src, dst, u128);
} else {
write_slice!(src, dst, u128, 16, Self::write_u128);
}
}
#[inline]
fn from_slice_u16(numbers: &mut [u16]) {
if cfg!(target_endian = "little") {
for n in numbers {
*n = n.to_be();
}
}
}
#[inline]
fn from_slice_u32(numbers: &mut [u32]) {
if cfg!(target_endian = "little") {
for n in numbers {
*n = n.to_be();
}
}
}
#[inline]
fn from_slice_u64(numbers: &mut [u64]) {
if cfg!(target_endian = "little") {
for n in numbers {
*n = n.to_be();
}
}
}
#[inline]
fn from_slice_u128(numbers: &mut [u128]) {
if cfg!(target_endian = "little") {
for n in numbers {
*n = n.to_be();
}
}
}
#[inline]
fn from_slice_f32(numbers: &mut [f32]) {
if cfg!(target_endian = "little") {
for n in numbers {
unsafe {
let int = *(n as *const f32 as *const u32);
*n = *(&int.to_be() as *const u32 as *const f32);
}
}
}
}
#[inline]
fn from_slice_f64(numbers: &mut [f64]) {
if cfg!(target_endian = "little") {
for n in numbers {
unsafe {
let int = *(n as *const f64 as *const u64);
*n = *(&int.to_be() as *const u64 as *const f64);
}
}
}
}
}
impl ByteOrder for LittleEndian {
#[inline]
fn read_u16(buf: &[u8]) -> u16 {
u16::from_le_bytes(buf[..2].try_into().unwrap())
}
#[inline]
fn read_u32(buf: &[u8]) -> u32 {
u32::from_le_bytes(buf[..4].try_into().unwrap())
}
#[inline]
fn read_u64(buf: &[u8]) -> u64 {
u64::from_le_bytes(buf[..8].try_into().unwrap())
}
#[inline]
fn read_u128(buf: &[u8]) -> u128 {
u128::from_le_bytes(buf[..16].try_into().unwrap())
}
#[inline]
fn read_uint(buf: &[u8], nbytes: usize) -> u64 {
assert!(1 <= nbytes && nbytes <= 8 && nbytes <= buf.len());
let mut out = 0u64;
let ptr_out = &mut out as *mut u64 as *mut u8;
unsafe {
copy_nonoverlapping(buf.as_ptr(), ptr_out, nbytes);
}
out.to_le()
}
#[inline]
fn read_uint128(buf: &[u8], nbytes: usize) -> u128 {
assert!(1 <= nbytes && nbytes <= 16 && nbytes <= buf.len());
let mut out: u128 = 0;
let ptr_out = &mut out as *mut u128 as *mut u8;
unsafe {
copy_nonoverlapping(buf.as_ptr(), ptr_out, nbytes);
}
out.to_le()
}
#[inline]
fn write_u16(buf: &mut [u8], n: u16) {
unsafe_write_num_bytes!(u16, 2, n, buf, to_le);
}
#[inline]
fn write_u32(buf: &mut [u8], n: u32) {
unsafe_write_num_bytes!(u32, 4, n, buf, to_le);
}
#[inline]
fn write_u64(buf: &mut [u8], n: u64) {
unsafe_write_num_bytes!(u64, 8, n, buf, to_le);
}
#[inline]
fn write_u128(buf: &mut [u8], n: u128) {
unsafe_write_num_bytes!(u128, 16, n, buf, to_le);
}
#[inline]
fn write_uint(buf: &mut [u8], n: u64, nbytes: usize) {
assert!(pack_size(n as u64) <= nbytes && nbytes <= 8);
assert!(nbytes <= buf.len());
unsafe {
let bytes = *(&n.to_le() as *const u64 as *const [u8; 8]);
copy_nonoverlapping(bytes.as_ptr(), buf.as_mut_ptr(), nbytes);
}
}
#[inline]
fn write_uint128(buf: &mut [u8], n: u128, nbytes: usize) {
assert!(pack_size128(n as u128) <= nbytes && nbytes <= 16);
assert!(nbytes <= buf.len());
unsafe {
let bytes = *(&n.to_le() as *const u128 as *const [u8; 16]);
copy_nonoverlapping(bytes.as_ptr(), buf.as_mut_ptr(), nbytes);
}
}
#[inline]
fn read_u16_into(src: &[u8], dst: &mut [u16]) {
unsafe_read_slice!(src, dst, 2, to_le);
}
#[inline]
fn read_u32_into(src: &[u8], dst: &mut [u32]) {
unsafe_read_slice!(src, dst, 4, to_le);
}
#[inline]
fn read_u64_into(src: &[u8], dst: &mut [u64]) {
unsafe_read_slice!(src, dst, 8, to_le);
}
#[inline]
fn read_u128_into(src: &[u8], dst: &mut [u128]) {
unsafe_read_slice!(src, dst, 16, to_le);
}
#[inline]
fn write_u16_into(src: &[u16], dst: &mut [u8]) {
if cfg!(target_endian = "little") {
unsafe_write_slice_native!(src, dst, u16);
} else {
write_slice!(src, dst, u16, 2, Self::write_u16);
}
}
#[inline]
fn write_u32_into(src: &[u32], dst: &mut [u8]) {
if cfg!(target_endian = "little") {
unsafe_write_slice_native!(src, dst, u32);
} else {
write_slice!(src, dst, u32, 4, Self::write_u32);
}
}
#[inline]
fn write_u64_into(src: &[u64], dst: &mut [u8]) {
if cfg!(target_endian = "little") {
unsafe_write_slice_native!(src, dst, u64);
} else {
write_slice!(src, dst, u64, 8, Self::write_u64);
}
}
#[inline]
fn write_u128_into(src: &[u128], dst: &mut [u8]) {
if cfg!(target_endian = "little") {
unsafe_write_slice_native!(src, dst, u128);
} else {
write_slice!(src, dst, u128, 16, Self::write_u128);
}
}
#[inline]
fn from_slice_u16(numbers: &mut [u16]) {
if cfg!(target_endian = "big") {
for n in numbers {
*n = n.to_le();
}
}
}
#[inline]
fn from_slice_u32(numbers: &mut [u32]) {
if cfg!(target_endian = "big") {
for n in numbers {
*n = n.to_le();
}
}
}
#[inline]
fn from_slice_u64(numbers: &mut [u64]) {
if cfg!(target_endian = "big") {
for n in numbers {
*n = n.to_le();
}
}
}
#[inline]
fn from_slice_u128(numbers: &mut [u128]) {
if cfg!(target_endian = "big") {
for n in numbers {
*n = n.to_le();
}
}
}
#[inline]
fn from_slice_f32(numbers: &mut [f32]) {
if cfg!(target_endian = "big") {
for n in numbers {
unsafe {
let int = *(n as *const f32 as *const u32);
*n = *(&int.to_le() as *const u32 as *const f32);
}
}
}
}
#[inline]
fn from_slice_f64(numbers: &mut [f64]) {
if cfg!(target_endian = "big") {
for n in numbers {
unsafe {
let int = *(n as *const f64 as *const u64);
*n = *(&int.to_le() as *const u64 as *const f64);
}
}
}
}
}
#[cfg(test)]
mod test {
use quickcheck::{Arbitrary, Gen, QuickCheck, StdGen, Testable};
use rand::{thread_rng, Rng};
pub const U24_MAX: u32 = 16_777_215;
pub const I24_MAX: i32 = 8_388_607;
pub const U48_MAX: u64 = 281_474_976_710_655;
pub const I48_MAX: i64 = 140_737_488_355_327;
pub const U64_MAX: u64 = ::core::u64::MAX;
pub const I64_MAX: u64 = ::core::i64::MAX as u64;
macro_rules! calc_max {
($max:expr, $bytes:expr) => {
calc_max!($max, $bytes, 8)
};
($max:expr, $bytes:expr, $maxbytes:expr) => {
($max - 1) >> (8 * ($maxbytes - $bytes))
};
}
#[derive(Clone, Debug)]
pub struct Wi128<T>(pub T);
impl<T: Clone> Wi128<T> {
pub fn clone(&self) -> T {
self.0.clone()
}
}
impl<T: PartialEq> PartialEq<T> for Wi128<T> {
fn eq(&self, other: &T) -> bool {
self.0.eq(other)
}
}
impl Arbitrary for Wi128<u128> {
fn arbitrary<G: Gen>(gen: &mut G) -> Wi128<u128> {
let max = calc_max!(::core::u128::MAX, gen.size(), 16);
let output = (gen.gen::<u64>() as u128)
| ((gen.gen::<u64>() as u128) << 64);
Wi128(output & (max - 1))
}
}
impl Arbitrary for Wi128<i128> {
fn arbitrary<G: Gen>(gen: &mut G) -> Wi128<i128> {
let max = calc_max!(::core::i128::MAX, gen.size(), 16);
let output = (gen.gen::<i64>() as i128)
| ((gen.gen::<i64>() as i128) << 64);
Wi128(output & (max - 1))
}
}
pub fn qc_sized<A: Testable>(f: A, size: u64) {
QuickCheck::new()
.gen(StdGen::new(thread_rng(), size as usize))
.tests(1_00)
.max_tests(10_000)
.quickcheck(f);
}
macro_rules! qc_byte_order {
($name:ident, $ty_int:ty, $max:expr,
$bytes:expr, $read:ident, $write:ident) => {
mod $name {
#[allow(unused_imports)]
use super::{qc_sized, Wi128};
use crate::{
BigEndian, ByteOrder, LittleEndian, NativeEndian,
};
#[test]
fn big_endian() {
fn prop(n: $ty_int) -> bool {
let mut buf = [0; 16];
BigEndian::$write(&mut buf, n.clone(), $bytes);
n == BigEndian::$read(&buf[..$bytes], $bytes)
}
qc_sized(prop as fn($ty_int) -> bool, $max);
}
#[test]
fn little_endian() {
fn prop(n: $ty_int) -> bool {
let mut buf = [0; 16];
LittleEndian::$write(&mut buf, n.clone(), $bytes);
n == LittleEndian::$read(&buf[..$bytes], $bytes)
}
qc_sized(prop as fn($ty_int) -> bool, $max);
}
#[test]
fn native_endian() {
fn prop(n: $ty_int) -> bool {
let mut buf = [0; 16];
NativeEndian::$write(&mut buf, n.clone(), $bytes);
n == NativeEndian::$read(&buf[..$bytes], $bytes)
}
qc_sized(prop as fn($ty_int) -> bool, $max);
}
}
};
($name:ident, $ty_int:ty, $max:expr,
$read:ident, $write:ident) => {
mod $name {
#[allow(unused_imports)]
use super::{qc_sized, Wi128};
use crate::{
BigEndian, ByteOrder, LittleEndian, NativeEndian,
};
use core::mem::size_of;
#[test]
fn big_endian() {
fn prop(n: $ty_int) -> bool {
let bytes = size_of::<$ty_int>();
let mut buf = [0; 16];
BigEndian::$write(&mut buf[16 - bytes..], n.clone());
n == BigEndian::$read(&buf[16 - bytes..])
}
qc_sized(prop as fn($ty_int) -> bool, $max - 1);
}
#[test]
fn little_endian() {
fn prop(n: $ty_int) -> bool {
let bytes = size_of::<$ty_int>();
let mut buf = [0; 16];
LittleEndian::$write(&mut buf[..bytes], n.clone());
n == LittleEndian::$read(&buf[..bytes])
}
qc_sized(prop as fn($ty_int) -> bool, $max - 1);
}
#[test]
fn native_endian() {
fn prop(n: $ty_int) -> bool {
let bytes = size_of::<$ty_int>();
let mut buf = [0; 16];
NativeEndian::$write(&mut buf[..bytes], n.clone());
n == NativeEndian::$read(&buf[..bytes])
}
qc_sized(prop as fn($ty_int) -> bool, $max - 1);
}
}
};
}
qc_byte_order!(
prop_u16,
u16,
::core::u16::MAX as u64,
read_u16,
write_u16
);
qc_byte_order!(
prop_i16,
i16,
::core::i16::MAX as u64,
read_i16,
write_i16
);
qc_byte_order!(
prop_u24,
u32,
crate::test::U24_MAX as u64,
read_u24,
write_u24
);
qc_byte_order!(
prop_i24,
i32,
crate::test::I24_MAX as u64,
read_i24,
write_i24
);
qc_byte_order!(
prop_u32,
u32,
::core::u32::MAX as u64,
read_u32,
write_u32
);
qc_byte_order!(
prop_i32,
i32,
::core::i32::MAX as u64,
read_i32,
write_i32
);
qc_byte_order!(
prop_u48,
u64,
crate::test::U48_MAX as u64,
read_u48,
write_u48
);
qc_byte_order!(
prop_i48,
i64,
crate::test::I48_MAX as u64,
read_i48,
write_i48
);
qc_byte_order!(
prop_u64,
u64,
::core::u64::MAX as u64,
read_u64,
write_u64
);
qc_byte_order!(
prop_i64,
i64,
::core::i64::MAX as u64,
read_i64,
write_i64
);
qc_byte_order!(
prop_f32,
f32,
::core::u64::MAX as u64,
read_f32,
write_f32
);
qc_byte_order!(
prop_f64,
f64,
::core::i64::MAX as u64,
read_f64,
write_f64
);
qc_byte_order!(prop_u128, Wi128<u128>, 16 + 1, read_u128, write_u128);
qc_byte_order!(prop_i128, Wi128<i128>, 16 + 1, read_i128, write_i128);
qc_byte_order!(
prop_uint_1,
u64,
calc_max!(super::U64_MAX, 1),
1,
read_uint,
write_uint
);
qc_byte_order!(
prop_uint_2,
u64,
calc_max!(super::U64_MAX, 2),
2,
read_uint,
write_uint
);
qc_byte_order!(
prop_uint_3,
u64,
calc_max!(super::U64_MAX, 3),
3,
read_uint,
write_uint
);
qc_byte_order!(
prop_uint_4,
u64,
calc_max!(super::U64_MAX, 4),
4,
read_uint,
write_uint
);
qc_byte_order!(
prop_uint_5,
u64,
calc_max!(super::U64_MAX, 5),
5,
read_uint,
write_uint
);
qc_byte_order!(
prop_uint_6,
u64,
calc_max!(super::U64_MAX, 6),
6,
read_uint,
write_uint
);
qc_byte_order!(
prop_uint_7,
u64,
calc_max!(super::U64_MAX, 7),
7,
read_uint,
write_uint
);
qc_byte_order!(
prop_uint_8,
u64,
calc_max!(super::U64_MAX, 8),
8,
read_uint,
write_uint
);
qc_byte_order!(
prop_uint128_1,
Wi128<u128>,
1,
1,
read_uint128,
write_uint128
);
qc_byte_order!(
prop_uint128_2,
Wi128<u128>,
2,
2,
read_uint128,
write_uint128
);
qc_byte_order!(
prop_uint128_3,
Wi128<u128>,
3,
3,
read_uint128,
write_uint128
);
qc_byte_order!(
prop_uint128_4,
Wi128<u128>,
4,
4,
read_uint128,
write_uint128
);
qc_byte_order!(
prop_uint128_5,
Wi128<u128>,
5,
5,
read_uint128,
write_uint128
);
qc_byte_order!(
prop_uint128_6,
Wi128<u128>,
6,
6,
read_uint128,
write_uint128
);
qc_byte_order!(
prop_uint128_7,
Wi128<u128>,
7,
7,
read_uint128,
write_uint128
);
qc_byte_order!(
prop_uint128_8,
Wi128<u128>,
8,
8,
read_uint128,
write_uint128
);
qc_byte_order!(
prop_uint128_9,
Wi128<u128>,
9,
9,
read_uint128,
write_uint128
);
qc_byte_order!(
prop_uint128_10,
Wi128<u128>,
10,
10,
read_uint128,
write_uint128
);
qc_byte_order!(
prop_uint128_11,
Wi128<u128>,
11,
11,
read_uint128,
write_uint128
);
qc_byte_order!(
prop_uint128_12,
Wi128<u128>,
12,
12,
read_uint128,
write_uint128
);
qc_byte_order!(
prop_uint128_13,
Wi128<u128>,
13,
13,
read_uint128,
write_uint128
);
qc_byte_order!(
prop_uint128_14,
Wi128<u128>,
14,
14,
read_uint128,
write_uint128
);
qc_byte_order!(
prop_uint128_15,
Wi128<u128>,
15,
15,
read_uint128,
write_uint128
);
qc_byte_order!(
prop_uint128_16,
Wi128<u128>,
16,
16,
read_uint128,
write_uint128
);
qc_byte_order!(
prop_int_1,
i64,
calc_max!(super::I64_MAX, 1),
1,
read_int,
write_int
);
qc_byte_order!(
prop_int_2,
i64,
calc_max!(super::I64_MAX, 2),
2,
read_int,
write_int
);
qc_byte_order!(
prop_int_3,
i64,
calc_max!(super::I64_MAX, 3),
3,
read_int,
write_int
);
qc_byte_order!(
prop_int_4,
i64,
calc_max!(super::I64_MAX, 4),
4,
read_int,
write_int
);
qc_byte_order!(
prop_int_5,
i64,
calc_max!(super::I64_MAX, 5),
5,
read_int,
write_int
);
qc_byte_order!(
prop_int_6,
i64,
calc_max!(super::I64_MAX, 6),
6,
read_int,
write_int
);
qc_byte_order!(
prop_int_7,
i64,
calc_max!(super::I64_MAX, 7),
7,
read_int,
write_int
);
qc_byte_order!(
prop_int_8,
i64,
calc_max!(super::I64_MAX, 8),
8,
read_int,
write_int
);
qc_byte_order!(
prop_int128_1,
Wi128<i128>,
1,
1,
read_int128,
write_int128
);
qc_byte_order!(
prop_int128_2,
Wi128<i128>,
2,
2,
read_int128,
write_int128
);
qc_byte_order!(
prop_int128_3,
Wi128<i128>,
3,
3,
read_int128,
write_int128
);
qc_byte_order!(
prop_int128_4,
Wi128<i128>,
4,
4,
read_int128,
write_int128
);
qc_byte_order!(
prop_int128_5,
Wi128<i128>,
5,
5,
read_int128,
write_int128
);
qc_byte_order!(
prop_int128_6,
Wi128<i128>,
6,
6,
read_int128,
write_int128
);
qc_byte_order!(
prop_int128_7,
Wi128<i128>,
7,
7,
read_int128,
write_int128
);
qc_byte_order!(
prop_int128_8,
Wi128<i128>,
8,
8,
read_int128,
write_int128
);
qc_byte_order!(
prop_int128_9,
Wi128<i128>,
9,
9,
read_int128,
write_int128
);
qc_byte_order!(
prop_int128_10,
Wi128<i128>,
10,
10,
read_int128,
write_int128
);
qc_byte_order!(
prop_int128_11,
Wi128<i128>,
11,
11,
read_int128,
write_int128
);
qc_byte_order!(
prop_int128_12,
Wi128<i128>,
12,
12,
read_int128,
write_int128
);
qc_byte_order!(
prop_int128_13,
Wi128<i128>,
13,
13,
read_int128,
write_int128
);
qc_byte_order!(
prop_int128_14,
Wi128<i128>,
14,
14,
read_int128,
write_int128
);
qc_byte_order!(
prop_int128_15,
Wi128<i128>,
15,
15,
read_int128,
write_int128
);
qc_byte_order!(
prop_int128_16,
Wi128<i128>,
16,
16,
read_int128,
write_int128
);
// Test that all of the byte conversion functions panic when given a
// buffer that is too small.
//
// These tests are critical to ensure safety, otherwise we might end up
// with a buffer overflow.
macro_rules! too_small {
($name:ident, $maximally_small:expr, $zero:expr,
$read:ident, $write:ident) => {
mod $name {
use crate::{
BigEndian, ByteOrder, LittleEndian, NativeEndian,
};
#[test]
#[should_panic]
fn read_big_endian() {
let buf = [0; $maximally_small];
BigEndian::$read(&buf);
}
#[test]
#[should_panic]
fn read_little_endian() {
let buf = [0; $maximally_small];
LittleEndian::$read(&buf);
}
#[test]
#[should_panic]
fn read_native_endian() {
let buf = [0; $maximally_small];
NativeEndian::$read(&buf);
}
#[test]
#[should_panic]
fn write_big_endian() {
let mut buf = [0; $maximally_small];
BigEndian::$write(&mut buf, $zero);
}
#[test]
#[should_panic]
fn write_little_endian() {
let mut buf = [0; $maximally_small];
LittleEndian::$write(&mut buf, $zero);
}
#[test]
#[should_panic]
fn write_native_endian() {
let mut buf = [0; $maximally_small];
NativeEndian::$write(&mut buf, $zero);
}
}
};
($name:ident, $maximally_small:expr, $read:ident) => {
mod $name {
use crate::{
BigEndian, ByteOrder, LittleEndian, NativeEndian,
};
#[test]
#[should_panic]
fn read_big_endian() {
let buf = [0; $maximally_small];
BigEndian::$read(&buf, $maximally_small + 1);
}
#[test]
#[should_panic]
fn read_little_endian() {
let buf = [0; $maximally_small];
LittleEndian::$read(&buf, $maximally_small + 1);
}
#[test]
#[should_panic]
fn read_native_endian() {
let buf = [0; $maximally_small];
NativeEndian::$read(&buf, $maximally_small + 1);
}
}
};
}
too_small!(small_u16, 1, 0, read_u16, write_u16);
too_small!(small_i16, 1, 0, read_i16, write_i16);
too_small!(small_u32, 3, 0, read_u32, write_u32);
too_small!(small_i32, 3, 0, read_i32, write_i32);
too_small!(small_u64, 7, 0, read_u64, write_u64);
too_small!(small_i64, 7, 0, read_i64, write_i64);
too_small!(small_f32, 3, 0.0, read_f32, write_f32);
too_small!(small_f64, 7, 0.0, read_f64, write_f64);
too_small!(small_u128, 15, 0, read_u128, write_u128);
too_small!(small_i128, 15, 0, read_i128, write_i128);
too_small!(small_uint_1, 1, read_uint);
too_small!(small_uint_2, 2, read_uint);
too_small!(small_uint_3, 3, read_uint);
too_small!(small_uint_4, 4, read_uint);
too_small!(small_uint_5, 5, read_uint);
too_small!(small_uint_6, 6, read_uint);
too_small!(small_uint_7, 7, read_uint);
too_small!(small_uint128_1, 1, read_uint128);
too_small!(small_uint128_2, 2, read_uint128);
too_small!(small_uint128_3, 3, read_uint128);
too_small!(small_uint128_4, 4, read_uint128);
too_small!(small_uint128_5, 5, read_uint128);
too_small!(small_uint128_6, 6, read_uint128);
too_small!(small_uint128_7, 7, read_uint128);
too_small!(small_uint128_8, 8, read_uint128);
too_small!(small_uint128_9, 9, read_uint128);
too_small!(small_uint128_10, 10, read_uint128);
too_small!(small_uint128_11, 11, read_uint128);
too_small!(small_uint128_12, 12, read_uint128);
too_small!(small_uint128_13, 13, read_uint128);
too_small!(small_uint128_14, 14, read_uint128);
too_small!(small_uint128_15, 15, read_uint128);
too_small!(small_int_1, 1, read_int);
too_small!(small_int_2, 2, read_int);
too_small!(small_int_3, 3, read_int);
too_small!(small_int_4, 4, read_int);
too_small!(small_int_5, 5, read_int);
too_small!(small_int_6, 6, read_int);
too_small!(small_int_7, 7, read_int);
too_small!(small_int128_1, 1, read_int128);
too_small!(small_int128_2, 2, read_int128);
too_small!(small_int128_3, 3, read_int128);
too_small!(small_int128_4, 4, read_int128);
too_small!(small_int128_5, 5, read_int128);
too_small!(small_int128_6, 6, read_int128);
too_small!(small_int128_7, 7, read_int128);
too_small!(small_int128_8, 8, read_int128);
too_small!(small_int128_9, 9, read_int128);
too_small!(small_int128_10, 10, read_int128);
too_small!(small_int128_11, 11, read_int128);
too_small!(small_int128_12, 12, read_int128);
too_small!(small_int128_13, 13, read_int128);
too_small!(small_int128_14, 14, read_int128);
too_small!(small_int128_15, 15, read_int128);
// Test that reading/writing slices enforces the correct lengths.
macro_rules! slice_lengths {
($name:ident, $read:ident, $write:ident,
$num_bytes:expr, $numbers:expr) => {
mod $name {
use crate::{
BigEndian, ByteOrder, LittleEndian, NativeEndian,
};
#[test]
#[should_panic]
fn read_big_endian() {
let bytes = [0; $num_bytes];
let mut numbers = $numbers;
BigEndian::$read(&bytes, &mut numbers);
}
#[test]
#[should_panic]
fn read_little_endian() {
let bytes = [0; $num_bytes];
let mut numbers = $numbers;
LittleEndian::$read(&bytes, &mut numbers);
}
#[test]
#[should_panic]
fn read_native_endian() {
let bytes = [0; $num_bytes];
let mut numbers = $numbers;
NativeEndian::$read(&bytes, &mut numbers);
}
#[test]
#[should_panic]
fn write_big_endian() {
let mut bytes = [0; $num_bytes];
let numbers = $numbers;
BigEndian::$write(&numbers, &mut bytes);
}
#[test]
#[should_panic]
fn write_little_endian() {
let mut bytes = [0; $num_bytes];
let numbers = $numbers;
LittleEndian::$write(&numbers, &mut bytes);
}
#[test]
#[should_panic]
fn write_native_endian() {
let mut bytes = [0; $num_bytes];
let numbers = $numbers;
NativeEndian::$write(&numbers, &mut bytes);
}
}
};
}
slice_lengths!(
slice_len_too_small_u16,
read_u16_into,
write_u16_into,
3,
[0, 0]
);
slice_lengths!(
slice_len_too_big_u16,
read_u16_into,
write_u16_into,
5,
[0, 0]
);
slice_lengths!(
slice_len_too_small_i16,
read_i16_into,
write_i16_into,
3,
[0, 0]
);
slice_lengths!(
slice_len_too_big_i16,
read_i16_into,
write_i16_into,
5,
[0, 0]
);
slice_lengths!(
slice_len_too_small_u32,
read_u32_into,
write_u32_into,
7,
[0, 0]
);
slice_lengths!(
slice_len_too_big_u32,
read_u32_into,
write_u32_into,
9,
[0, 0]
);
slice_lengths!(
slice_len_too_small_i32,
read_i32_into,
write_i32_into,
7,
[0, 0]
);
slice_lengths!(
slice_len_too_big_i32,
read_i32_into,
write_i32_into,
9,
[0, 0]
);
slice_lengths!(
slice_len_too_small_u64,
read_u64_into,
write_u64_into,
15,
[0, 0]
);
slice_lengths!(
slice_len_too_big_u64,
read_u64_into,
write_u64_into,
17,
[0, 0]
);
slice_lengths!(
slice_len_too_small_i64,
read_i64_into,
write_i64_into,
15,
[0, 0]
);
slice_lengths!(
slice_len_too_big_i64,
read_i64_into,
write_i64_into,
17,
[0, 0]
);
slice_lengths!(
slice_len_too_small_u128,
read_u128_into,
write_u128_into,
31,
[0, 0]
);
slice_lengths!(
slice_len_too_big_u128,
read_u128_into,
write_u128_into,
33,
[0, 0]
);
slice_lengths!(
slice_len_too_small_i128,
read_i128_into,
write_i128_into,
31,
[0, 0]
);
slice_lengths!(
slice_len_too_big_i128,
read_i128_into,
write_i128_into,
33,
[0, 0]
);
#[test]
fn uint_bigger_buffer() {
use crate::{ByteOrder, LittleEndian};
let n = LittleEndian::read_uint(&[1, 2, 3, 4, 5, 6, 7, 8], 5);
assert_eq!(n, 0x05_0403_0201);
}
#[test]
fn regression173_array_impl() {
use crate::{BigEndian, ByteOrder, LittleEndian};
let xs = [0; 100];
let x = BigEndian::read_u16(&xs);
assert_eq!(x, 0);
let x = BigEndian::read_u32(&xs);
assert_eq!(x, 0);
let x = BigEndian::read_u64(&xs);
assert_eq!(x, 0);
let x = BigEndian::read_u128(&xs);
assert_eq!(x, 0);
let x = BigEndian::read_i16(&xs);
assert_eq!(x, 0);
let x = BigEndian::read_i32(&xs);
assert_eq!(x, 0);
let x = BigEndian::read_i64(&xs);
assert_eq!(x, 0);
let x = BigEndian::read_i128(&xs);
assert_eq!(x, 0);
let x = LittleEndian::read_u16(&xs);
assert_eq!(x, 0);
let x = LittleEndian::read_u32(&xs);
assert_eq!(x, 0);
let x = LittleEndian::read_u64(&xs);
assert_eq!(x, 0);
let x = LittleEndian::read_u128(&xs);
assert_eq!(x, 0);
let x = LittleEndian::read_i16(&xs);
assert_eq!(x, 0);
let x = LittleEndian::read_i32(&xs);
assert_eq!(x, 0);
let x = LittleEndian::read_i64(&xs);
assert_eq!(x, 0);
let x = LittleEndian::read_i128(&xs);
assert_eq!(x, 0);
}
}
#[cfg(test)]
#[cfg(feature = "std")]
mod stdtests {
extern crate quickcheck;
extern crate rand;
use self::quickcheck::{QuickCheck, StdGen, Testable};
use self::rand::thread_rng;
fn qc_unsized<A: Testable>(f: A) {
QuickCheck::new()
.gen(StdGen::new(thread_rng(), 16))
.tests(1_00)
.max_tests(10_000)
.quickcheck(f);
}
macro_rules! calc_max {
($max:expr, $bytes:expr) => {
($max - 1) >> (8 * (8 - $bytes))
};
}
macro_rules! qc_bytes_ext {
($name:ident, $ty_int:ty, $max:expr,
$bytes:expr, $read:ident, $write:ident) => {
mod $name {
#[allow(unused_imports)]
use crate::test::{qc_sized, Wi128};
use crate::{
BigEndian, LittleEndian, NativeEndian, ReadBytesExt,
WriteBytesExt,
};
use std::io::Cursor;
#[test]
fn big_endian() {
fn prop(n: $ty_int) -> bool {
let mut wtr = vec![];
wtr.$write::<BigEndian>(n.clone()).unwrap();
let offset = wtr.len() - $bytes;
let mut rdr = Cursor::new(&mut wtr[offset..]);
n == rdr.$read::<BigEndian>($bytes).unwrap()
}
qc_sized(prop as fn($ty_int) -> bool, $max);
}
#[test]
fn little_endian() {
fn prop(n: $ty_int) -> bool {
let mut wtr = vec![];
wtr.$write::<LittleEndian>(n.clone()).unwrap();
let mut rdr = Cursor::new(wtr);
n == rdr.$read::<LittleEndian>($bytes).unwrap()
}
qc_sized(prop as fn($ty_int) -> bool, $max);
}
#[test]
fn native_endian() {
fn prop(n: $ty_int) -> bool {
let mut wtr = vec![];
wtr.$write::<NativeEndian>(n.clone()).unwrap();
let offset = if cfg!(target_endian = "big") {
wtr.len() - $bytes
} else {
0
};
let mut rdr = Cursor::new(&mut wtr[offset..]);
n == rdr.$read::<NativeEndian>($bytes).unwrap()
}
qc_sized(prop as fn($ty_int) -> bool, $max);
}
}
};
($name:ident, $ty_int:ty, $max:expr, $read:ident, $write:ident) => {
mod $name {
#[allow(unused_imports)]
use crate::test::{qc_sized, Wi128};
use crate::{
BigEndian, LittleEndian, NativeEndian, ReadBytesExt,
WriteBytesExt,
};
use std::io::Cursor;
#[test]
fn big_endian() {
fn prop(n: $ty_int) -> bool {
let mut wtr = vec![];
wtr.$write::<BigEndian>(n.clone()).unwrap();
let mut rdr = Cursor::new(wtr);
n == rdr.$read::<BigEndian>().unwrap()
}
qc_sized(prop as fn($ty_int) -> bool, $max - 1);
}
#[test]
fn little_endian() {
fn prop(n: $ty_int) -> bool {
let mut wtr = vec![];
wtr.$write::<LittleEndian>(n.clone()).unwrap();
let mut rdr = Cursor::new(wtr);
n == rdr.$read::<LittleEndian>().unwrap()
}
qc_sized(prop as fn($ty_int) -> bool, $max - 1);
}
#[test]
fn native_endian() {
fn prop(n: $ty_int) -> bool {
let mut wtr = vec![];
wtr.$write::<NativeEndian>(n.clone()).unwrap();
let mut rdr = Cursor::new(wtr);
n == rdr.$read::<NativeEndian>().unwrap()
}
qc_sized(prop as fn($ty_int) -> bool, $max - 1);
}
}
};
}
qc_bytes_ext!(
prop_ext_u16,
u16,
::std::u16::MAX as u64,
read_u16,
write_u16
);
qc_bytes_ext!(
prop_ext_i16,
i16,
::std::i16::MAX as u64,
read_i16,
write_i16
);
qc_bytes_ext!(
prop_ext_u32,
u32,
::std::u32::MAX as u64,
read_u32,
write_u32
);
qc_bytes_ext!(
prop_ext_i32,
i32,
::std::i32::MAX as u64,
read_i32,
write_i32
);
qc_bytes_ext!(
prop_ext_u64,
u64,
::std::u64::MAX as u64,
read_u64,
write_u64
);
qc_bytes_ext!(
prop_ext_i64,
i64,
::std::i64::MAX as u64,
read_i64,
write_i64
);
qc_bytes_ext!(
prop_ext_f32,
f32,
::std::u64::MAX as u64,
read_f32,
write_f32
);
qc_bytes_ext!(
prop_ext_f64,
f64,
::std::i64::MAX as u64,
read_f64,
write_f64
);
qc_bytes_ext!(prop_ext_u128, Wi128<u128>, 16 + 1, read_u128, write_u128);
qc_bytes_ext!(prop_ext_i128, Wi128<i128>, 16 + 1, read_i128, write_i128);
qc_bytes_ext!(
prop_ext_uint_1,
u64,
calc_max!(crate::test::U64_MAX, 1),
1,
read_uint,
write_u64
);
qc_bytes_ext!(
prop_ext_uint_2,
u64,
calc_max!(crate::test::U64_MAX, 2),
2,
read_uint,
write_u64
);
qc_bytes_ext!(
prop_ext_uint_3,
u64,
calc_max!(crate::test::U64_MAX, 3),
3,
read_uint,
write_u64
);
qc_bytes_ext!(
prop_ext_uint_4,
u64,
calc_max!(crate::test::U64_MAX, 4),
4,
read_uint,
write_u64
);
qc_bytes_ext!(
prop_ext_uint_5,
u64,
calc_max!(crate::test::U64_MAX, 5),
5,
read_uint,
write_u64
);
qc_bytes_ext!(
prop_ext_uint_6,
u64,
calc_max!(crate::test::U64_MAX, 6),
6,
read_uint,
write_u64
);
qc_bytes_ext!(
prop_ext_uint_7,
u64,
calc_max!(crate::test::U64_MAX, 7),
7,
read_uint,
write_u64
);
qc_bytes_ext!(
prop_ext_uint_8,
u64,
calc_max!(crate::test::U64_MAX, 8),
8,
read_uint,
write_u64
);
qc_bytes_ext!(
prop_ext_uint128_1,
Wi128<u128>,
1,
1,
read_uint128,
write_u128
);
qc_bytes_ext!(
prop_ext_uint128_2,
Wi128<u128>,
2,
2,
read_uint128,
write_u128
);
qc_bytes_ext!(
prop_ext_uint128_3,
Wi128<u128>,
3,
3,
read_uint128,
write_u128
);
qc_bytes_ext!(
prop_ext_uint128_4,
Wi128<u128>,
4,
4,
read_uint128,
write_u128
);
qc_bytes_ext!(
prop_ext_uint128_5,
Wi128<u128>,
5,
5,
read_uint128,
write_u128
);
qc_bytes_ext!(
prop_ext_uint128_6,
Wi128<u128>,
6,
6,
read_uint128,
write_u128
);
qc_bytes_ext!(
prop_ext_uint128_7,
Wi128<u128>,
7,
7,
read_uint128,
write_u128
);
qc_bytes_ext!(
prop_ext_uint128_8,
Wi128<u128>,
8,
8,
read_uint128,
write_u128
);
qc_bytes_ext!(
prop_ext_uint128_9,
Wi128<u128>,
9,
9,
read_uint128,
write_u128
);
qc_bytes_ext!(
prop_ext_uint128_10,
Wi128<u128>,
10,
10,
read_uint128,
write_u128
);
qc_bytes_ext!(
prop_ext_uint128_11,
Wi128<u128>,
11,
11,
read_uint128,
write_u128
);
qc_bytes_ext!(
prop_ext_uint128_12,
Wi128<u128>,
12,
12,
read_uint128,
write_u128
);
qc_bytes_ext!(
prop_ext_uint128_13,
Wi128<u128>,
13,
13,
read_uint128,
write_u128
);
qc_bytes_ext!(
prop_ext_uint128_14,
Wi128<u128>,
14,
14,
read_uint128,
write_u128
);
qc_bytes_ext!(
prop_ext_uint128_15,
Wi128<u128>,
15,
15,
read_uint128,
write_u128
);
qc_bytes_ext!(
prop_ext_uint128_16,
Wi128<u128>,
16,
16,
read_uint128,
write_u128
);
qc_bytes_ext!(
prop_ext_int_1,
i64,
calc_max!(crate::test::I64_MAX, 1),
1,
read_int,
write_i64
);
qc_bytes_ext!(
prop_ext_int_2,
i64,
calc_max!(crate::test::I64_MAX, 2),
2,
read_int,
write_i64
);
qc_bytes_ext!(
prop_ext_int_3,
i64,
calc_max!(crate::test::I64_MAX, 3),
3,
read_int,
write_i64
);
qc_bytes_ext!(
prop_ext_int_4,
i64,
calc_max!(crate::test::I64_MAX, 4),
4,
read_int,
write_i64
);
qc_bytes_ext!(
prop_ext_int_5,
i64,
calc_max!(crate::test::I64_MAX, 5),
5,
read_int,
write_i64
);
qc_bytes_ext!(
prop_ext_int_6,
i64,
calc_max!(crate::test::I64_MAX, 6),
6,
read_int,
write_i64
);
qc_bytes_ext!(
prop_ext_int_7,
i64,
calc_max!(crate::test::I64_MAX, 1),
7,
read_int,
write_i64
);
qc_bytes_ext!(
prop_ext_int_8,
i64,
calc_max!(crate::test::I64_MAX, 8),
8,
read_int,
write_i64
);
qc_bytes_ext!(
prop_ext_int128_1,
Wi128<i128>,
1,
1,
read_int128,
write_i128
);
qc_bytes_ext!(
prop_ext_int128_2,
Wi128<i128>,
2,
2,
read_int128,
write_i128
);
qc_bytes_ext!(
prop_ext_int128_3,
Wi128<i128>,
3,
3,
read_int128,
write_i128
);
qc_bytes_ext!(
prop_ext_int128_4,
Wi128<i128>,
4,
4,
read_int128,
write_i128
);
qc_bytes_ext!(
prop_ext_int128_5,
Wi128<i128>,
5,
5,
read_int128,
write_i128
);
qc_bytes_ext!(
prop_ext_int128_6,
Wi128<i128>,
6,
6,
read_int128,
write_i128
);
qc_bytes_ext!(
prop_ext_int128_7,
Wi128<i128>,
7,
7,
read_int128,
write_i128
);
qc_bytes_ext!(
prop_ext_int128_8,
Wi128<i128>,
8,
8,
read_int128,
write_i128
);
qc_bytes_ext!(
prop_ext_int128_9,
Wi128<i128>,
9,
9,
read_int128,
write_i128
);
qc_bytes_ext!(
prop_ext_int128_10,
Wi128<i128>,
10,
10,
read_int128,
write_i128
);
qc_bytes_ext!(
prop_ext_int128_11,
Wi128<i128>,
11,
11,
read_int128,
write_i128
);
qc_bytes_ext!(
prop_ext_int128_12,
Wi128<i128>,
12,
12,
read_int128,
write_i128
);
qc_bytes_ext!(
prop_ext_int128_13,
Wi128<i128>,
13,
13,
read_int128,
write_i128
);
qc_bytes_ext!(
prop_ext_int128_14,
Wi128<i128>,
14,
14,
read_int128,
write_i128
);
qc_bytes_ext!(
prop_ext_int128_15,
Wi128<i128>,
15,
15,
read_int128,
write_i128
);
qc_bytes_ext!(
prop_ext_int128_16,
Wi128<i128>,
16,
16,
read_int128,
write_i128
);
// Test slice serialization/deserialization.
macro_rules! qc_slice {
($name:ident, $ty_int:ty, $read:ident, $write:ident, $zero:expr) => {
mod $name {
use super::qc_unsized;
#[allow(unused_imports)]
use crate::test::Wi128;
use crate::{
BigEndian, ByteOrder, LittleEndian, NativeEndian,
};
use core::mem::size_of;
#[test]
fn big_endian() {
#[allow(unused_unsafe)]
fn prop(numbers: Vec<$ty_int>) -> bool {
let numbers: Vec<_> =
numbers.into_iter().map(|x| x.clone()).collect();
let num_bytes = size_of::<$ty_int>() * numbers.len();
let mut bytes = vec![0; num_bytes];
BigEndian::$write(&numbers, &mut bytes);
let mut got = vec![$zero; numbers.len()];
unsafe {
BigEndian::$read(&bytes, &mut got);
}
numbers == got
}
qc_unsized(prop as fn(_) -> bool);
}
#[test]
fn little_endian() {
#[allow(unused_unsafe)]
fn prop(numbers: Vec<$ty_int>) -> bool {
let numbers: Vec<_> =
numbers.into_iter().map(|x| x.clone()).collect();
let num_bytes = size_of::<$ty_int>() * numbers.len();
let mut bytes = vec![0; num_bytes];
LittleEndian::$write(&numbers, &mut bytes);
let mut got = vec![$zero; numbers.len()];
unsafe {
LittleEndian::$read(&bytes, &mut got);
}
numbers == got
}
qc_unsized(prop as fn(_) -> bool);
}
#[test]
fn native_endian() {
#[allow(unused_unsafe)]
fn prop(numbers: Vec<$ty_int>) -> bool {
let numbers: Vec<_> =
numbers.into_iter().map(|x| x.clone()).collect();
let num_bytes = size_of::<$ty_int>() * numbers.len();
let mut bytes = vec![0; num_bytes];
NativeEndian::$write(&numbers, &mut bytes);
let mut got = vec![$zero; numbers.len()];
unsafe {
NativeEndian::$read(&bytes, &mut got);
}
numbers == got
}
qc_unsized(prop as fn(_) -> bool);
}
}
};
}
qc_slice!(prop_slice_u16, u16, read_u16_into, write_u16_into, 0);
qc_slice!(prop_slice_i16, i16, read_i16_into, write_i16_into, 0);
qc_slice!(prop_slice_u32, u32, read_u32_into, write_u32_into, 0);
qc_slice!(prop_slice_i32, i32, read_i32_into, write_i32_into, 0);
qc_slice!(prop_slice_u64, u64, read_u64_into, write_u64_into, 0);
qc_slice!(prop_slice_i64, i64, read_i64_into, write_i64_into, 0);
qc_slice!(
prop_slice_u128,
Wi128<u128>,
read_u128_into,
write_u128_into,
0
);
qc_slice!(
prop_slice_i128,
Wi128<i128>,
read_i128_into,
write_i128_into,
0
);
qc_slice!(prop_slice_f32, f32, read_f32_into, write_f32_into, 0.0);
qc_slice!(prop_slice_f64, f64, read_f64_into, write_f64_into, 0.0);
}
| {
"repo_name": "BurntSushi/byteorder",
"stars": "859",
"repo_language": "Rust",
"file_name": "bench.rs",
"mime_type": "text/plain"
} |
#![feature(test)]
extern crate test;
macro_rules! bench_num {
($name:ident, $read:ident, $bytes:expr, $data:expr) => {
mod $name {
use byteorder::{
BigEndian, ByteOrder, LittleEndian, NativeEndian,
};
use test::black_box as bb;
use test::Bencher;
const NITER: usize = 100_000;
#[bench]
fn read_big_endian(b: &mut Bencher) {
let buf = $data;
b.iter(|| {
for _ in 0..NITER {
bb(BigEndian::$read(&buf, $bytes));
}
});
}
#[bench]
fn read_little_endian(b: &mut Bencher) {
let buf = $data;
b.iter(|| {
for _ in 0..NITER {
bb(LittleEndian::$read(&buf, $bytes));
}
});
}
#[bench]
fn read_native_endian(b: &mut Bencher) {
let buf = $data;
b.iter(|| {
for _ in 0..NITER {
bb(NativeEndian::$read(&buf, $bytes));
}
});
}
}
};
($ty:ident, $max:ident,
$read:ident, $write:ident, $size:expr, $data:expr) => {
mod $ty {
use byteorder::{
BigEndian, ByteOrder, LittleEndian, NativeEndian,
};
use std::$ty;
use test::black_box as bb;
use test::Bencher;
const NITER: usize = 100_000;
#[bench]
fn read_big_endian(b: &mut Bencher) {
let buf = $data;
b.iter(|| {
for _ in 0..NITER {
bb(BigEndian::$read(&buf));
}
});
}
#[bench]
fn read_little_endian(b: &mut Bencher) {
let buf = $data;
b.iter(|| {
for _ in 0..NITER {
bb(LittleEndian::$read(&buf));
}
});
}
#[bench]
fn read_native_endian(b: &mut Bencher) {
let buf = $data;
b.iter(|| {
for _ in 0..NITER {
bb(NativeEndian::$read(&buf));
}
});
}
#[bench]
fn write_big_endian(b: &mut Bencher) {
let mut buf = $data;
let n = $ty::$max;
b.iter(|| {
for _ in 0..NITER {
bb(BigEndian::$write(&mut buf, n));
}
});
}
#[bench]
fn write_little_endian(b: &mut Bencher) {
let mut buf = $data;
let n = $ty::$max;
b.iter(|| {
for _ in 0..NITER {
bb(LittleEndian::$write(&mut buf, n));
}
});
}
#[bench]
fn write_native_endian(b: &mut Bencher) {
let mut buf = $data;
let n = $ty::$max;
b.iter(|| {
for _ in 0..NITER {
bb(NativeEndian::$write(&mut buf, n));
}
});
}
}
};
}
bench_num!(u16, MAX, read_u16, write_u16, 2, [1, 2]);
bench_num!(i16, MAX, read_i16, write_i16, 2, [1, 2]);
bench_num!(u32, MAX, read_u32, write_u32, 4, [1, 2, 3, 4]);
bench_num!(i32, MAX, read_i32, write_i32, 4, [1, 2, 3, 4]);
bench_num!(u64, MAX, read_u64, write_u64, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
bench_num!(i64, MAX, read_i64, write_i64, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
bench_num!(f32, MAX, read_f32, write_f32, 4, [1, 2, 3, 4]);
bench_num!(f64, MAX, read_f64, write_f64, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
bench_num!(uint_1, read_uint, 1, [1]);
bench_num!(uint_2, read_uint, 2, [1, 2]);
bench_num!(uint_3, read_uint, 3, [1, 2, 3]);
bench_num!(uint_4, read_uint, 4, [1, 2, 3, 4]);
bench_num!(uint_5, read_uint, 5, [1, 2, 3, 4, 5]);
bench_num!(uint_6, read_uint, 6, [1, 2, 3, 4, 5, 6]);
bench_num!(uint_7, read_uint, 7, [1, 2, 3, 4, 5, 6, 7]);
bench_num!(uint_8, read_uint, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
bench_num!(int_1, read_int, 1, [1]);
bench_num!(int_2, read_int, 2, [1, 2]);
bench_num!(int_3, read_int, 3, [1, 2, 3]);
bench_num!(int_4, read_int, 4, [1, 2, 3, 4]);
bench_num!(int_5, read_int, 5, [1, 2, 3, 4, 5]);
bench_num!(int_6, read_int, 6, [1, 2, 3, 4, 5, 6]);
bench_num!(int_7, read_int, 7, [1, 2, 3, 4, 5, 6, 7]);
bench_num!(int_8, read_int, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
bench_num!(
u128,
MAX,
read_u128,
write_u128,
16,
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
);
bench_num!(
i128,
MAX,
read_i128,
write_i128,
16,
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
);
bench_num!(uint128_1, read_uint128, 1, [1]);
bench_num!(uint128_2, read_uint128, 2, [1, 2]);
bench_num!(uint128_3, read_uint128, 3, [1, 2, 3]);
bench_num!(uint128_4, read_uint128, 4, [1, 2, 3, 4]);
bench_num!(uint128_5, read_uint128, 5, [1, 2, 3, 4, 5]);
bench_num!(uint128_6, read_uint128, 6, [1, 2, 3, 4, 5, 6]);
bench_num!(uint128_7, read_uint128, 7, [1, 2, 3, 4, 5, 6, 7]);
bench_num!(uint128_8, read_uint128, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
bench_num!(uint128_9, read_uint128, 9, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
bench_num!(uint128_10, read_uint128, 10, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
bench_num!(uint128_11, read_uint128, 11, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
bench_num!(
uint128_12,
read_uint128,
12,
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
);
bench_num!(
uint128_13,
read_uint128,
13,
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
);
bench_num!(
uint128_14,
read_uint128,
14,
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
);
bench_num!(
uint128_15,
read_uint128,
15,
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
);
bench_num!(
uint128_16,
read_uint128,
16,
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
);
bench_num!(int128_1, read_int128, 1, [1]);
bench_num!(int128_2, read_int128, 2, [1, 2]);
bench_num!(int128_3, read_int128, 3, [1, 2, 3]);
bench_num!(int128_4, read_int128, 4, [1, 2, 3, 4]);
bench_num!(int128_5, read_int128, 5, [1, 2, 3, 4, 5]);
bench_num!(int128_6, read_int128, 6, [1, 2, 3, 4, 5, 6]);
bench_num!(int128_7, read_int128, 7, [1, 2, 3, 4, 5, 6, 7]);
bench_num!(int128_8, read_int128, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
bench_num!(int128_9, read_int128, 9, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
bench_num!(int128_10, read_int128, 10, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
bench_num!(int128_11, read_int128, 11, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
bench_num!(
int128_12,
read_int128,
12,
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
);
bench_num!(
int128_13,
read_int128,
13,
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
);
bench_num!(
int128_14,
read_int128,
14,
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
);
bench_num!(
int128_15,
read_int128,
15,
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
);
bench_num!(
int128_16,
read_int128,
16,
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
);
macro_rules! bench_slice {
($name:ident, $numty:ty, $read:ident, $write:ident) => {
mod $name {
use std::mem::size_of;
use byteorder::{BigEndian, ByteOrder, LittleEndian};
use rand::distributions;
use rand::{self, Rng};
use test::Bencher;
#[bench]
fn read_big_endian(b: &mut Bencher) {
let mut numbers: Vec<$numty> = rand::thread_rng()
.sample_iter(&distributions::Standard)
.take(100000)
.collect();
let mut bytes = vec![0; numbers.len() * size_of::<$numty>()];
BigEndian::$write(&numbers, &mut bytes);
b.bytes = bytes.len() as u64;
b.iter(|| {
BigEndian::$read(&bytes, &mut numbers);
});
}
#[bench]
fn read_little_endian(b: &mut Bencher) {
let mut numbers: Vec<$numty> = rand::thread_rng()
.sample_iter(&distributions::Standard)
.take(100000)
.collect();
let mut bytes = vec![0; numbers.len() * size_of::<$numty>()];
LittleEndian::$write(&numbers, &mut bytes);
b.bytes = bytes.len() as u64;
b.iter(|| {
LittleEndian::$read(&bytes, &mut numbers);
});
}
#[bench]
fn write_big_endian(b: &mut Bencher) {
let numbers: Vec<$numty> = rand::thread_rng()
.sample_iter(&distributions::Standard)
.take(100000)
.collect();
let mut bytes = vec![0; numbers.len() * size_of::<$numty>()];
b.bytes = bytes.len() as u64;
b.iter(|| {
BigEndian::$write(&numbers, &mut bytes);
});
}
#[bench]
fn write_little_endian(b: &mut Bencher) {
let numbers: Vec<$numty> = rand::thread_rng()
.sample_iter(&distributions::Standard)
.take(100000)
.collect();
let mut bytes = vec![0; numbers.len() * size_of::<$numty>()];
b.bytes = bytes.len() as u64;
b.iter(|| {
LittleEndian::$write(&numbers, &mut bytes);
});
}
}
};
}
bench_slice!(slice_u64, u64, read_u64_into, write_u64_into);
| {
"repo_name": "BurntSushi/byteorder",
"stars": "859",
"repo_language": "Rust",
"file_name": "bench.rs",
"mime_type": "text/plain"
} |
# rust-learning
Advice for learning Rust
[Read the guide on Github Pages.](https://quinedot.github.io/rust-learning/)
## About
I'm mainly active in the Rust community via [URLO.](https://users.rust-lang.org/)
The first version of this guide has its roots in a post on the forum where someone
asked for general advice for understanding and fixing borrow-check errors. They
subseqently [asked if it could be made easier to find,](https://users.rust-lang.org/t/practical-suggestions-for-fixing-lifetime-errors/92634/17)
and I created this guide respository as a result.
Corrections and suggested additions are welcome, but be fore-warned that I
can be very slow and sporadic to respond on GitHub.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
[book]
author = "QuineDot"
title = "Learning Rust"
description = "Advice for learning Rust"
language = "en"
multilingual = false
src = "src"
[rust]
edition = "2021"
[output.html]
git-repository-url = "https://github.com/QuineDot/rust-learning"
default-theme = "navy"
site-url = "/rust-learning/"
fold.enable = true
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Erased traits
Let's say you have an existing trait which works well for the most part:
```rust
pub mod useful {
pub trait Iterable {
type Item;
type Iter<'a>: Iterator<Item = &'a Self::Item> where Self: 'a;
fn iter(&self) -> Self::Iter<'_>;
fn visit<F: FnMut(&Self::Item)>(&self, mut f: F) {
for item in self.iter() {
f(item);
}
}
}
impl<I: Iterable + ?Sized> Iterable for &I {
type Item = <I as Iterable>::Item;
type Iter<'a> = <I as Iterable>::Iter<'a> where Self: 'a;
fn iter(&self) -> Self::Iter<'_> {
<I as Iterable>::iter(*self)
}
}
impl<I: Iterable + ?Sized> Iterable for Box<I> {
type Item = <I as Iterable>::Item;
type Iter<'a> = <I as Iterable>::Iter<'a> where Self: 'a;
fn iter(&self) -> Self::Iter<'_> {
<I as Iterable>::iter(&**self)
}
}
impl<T> Iterable for Vec<T> {
type Item = T;
type Iter<'a> = std::slice::Iter<'a, T> where Self: 'a;
fn iter(&self) -> Self::Iter<'_> {
<[T]>::iter(self)
}
}
}
```
However, it's not [`dyn` safe](./dyn-safety.md) and you wish it was.
Even if we get support for GATs in `dyn Trait` some day, there
are no plans to support functions with generic type parameters
like `Iterable::visit`. Besides, you want the functionality now,
not "some day".
Perhaps you also have a lot of code utilizing this useful trait,
and you don't want to redo everything. Maybe it's not even your
own trait.
This may be a case where you want to provide an "erased" version
of the trait to make it `dyn` safe. The general idea is to use
`dyn` (type erasure) to replace all the non-`dyn`-safe uses such
as GATs and type-parameterized methods.
```rust
pub mod erased {
// This trait is `dyn` safe
pub trait Iterable {
type Item;
// No more GAT
fn iter(&self) -> Box<dyn Iterator<Item = &Self::Item> + '_>;
// No more type parameter
fn visit(&self, f: &mut dyn FnMut(&Self::Item));
}
}
```
We want to be able to create a `dyn erased::Iterable` from anything
that is `useful::Iterable`, so we need a blanket implementation to
connect the two:
```rust
#fn main() {}
#pub mod useful {
# pub trait Iterable {
# type Item;
# type Iter<'a>: Iterator<Item = &'a Self::Item> where Self: 'a;
# fn iter(&self) -> Self::Iter<'_>;
# fn visit<F: FnMut(&Self::Item)>(&self, f: F);
# }
#}
pub mod erased {
use crate::useful;
# pub trait Iterable {
# type Item;
# fn iter(&self) -> Box<dyn Iterator<Item = &Self::Item> + '_>;
# fn visit(&self, f: &mut dyn FnMut(&Self::Item)) {
# for item in self.iter() {
# f(item);
# }
# }
# }
impl<I: useful::Iterable + ?Sized> Iterable for I {
type Item = <I as useful::Iterable>::Item;
fn iter(&self) -> Box<dyn Iterator<Item = &Self::Item> + '_> {
Box::new(useful::Iterable::iter(self))
}
// By not using a default function body, we can avoid
// boxing up the iterator
fn visit(&self, f: &mut dyn FnMut(&Self::Item)) {
for item in <Self as useful::Iterable>::iter(self) {
f(item)
}
}
}
}
```
We're also going to want to pass our `erased::Iterable`s to functions
that have a `useful::Iterable` trait bound. However, we can't add
that as a supertrait, because that would remove the `dyn` safety.
The purpose of our `erased::Iterable` is to be able to type-erase to
`dyn erased::Iterable` anyway though, so instead we just implement
`useful::Iterable` directly on `dyn erased::Iterable`:
```rust
#fn main() {}
#pub mod useful {
# pub trait Iterable {
# type Item;
# type Iter<'a>: Iterator<Item = &'a Self::Item> where Self: 'a;
# fn iter(&self) -> Self::Iter<'_>;
# fn visit<F: FnMut(&Self::Item)>(&self, f: F);
# }
#}
pub mod erased {
use crate::useful;
# pub trait Iterable {
# type Item;
# fn iter(&self) -> Box<dyn Iterator<Item = &Self::Item> + '_>;
# fn visit(&self, f: &mut dyn FnMut(&Self::Item)) {
# for item in self.iter() {
# f(item);
# }
# }
# }
# impl<I: useful::Iterable + ?Sized> Iterable for I {
# type Item = <I as useful::Iterable>::Item;
# fn iter(&self) -> Box<dyn Iterator<Item = &Self::Item> + '_> {
# Box::new(useful::Iterable::iter(self))
# }
# fn visit(&self, f: &mut dyn FnMut(&Self::Item)) {
# for item in <Self as useful::Iterable>::iter(self) {
# f(item)
# }
# }
# }
impl<Item> useful::Iterable for dyn Iterable<Item = Item> + '_ {
type Item = Item;
type Iter<'a> = Box<dyn Iterator<Item = &'a Item> + 'a> where Self: 'a;
fn iter(&self) -> Self::Iter<'_> {
Iterable::iter(self)
}
// Here we can choose to override the default function body to avoid
// boxing up the iterator, or we can use the default function body
// to avoid dynamic dispatch of `F`. I've opted for the former.
fn visit<F: FnMut(&Self::Item)>(&self, mut f: F) {
<Self as Iterable>::visit(self, &mut f)
}
}
}
```
Technically our blanket implementation of `erased::Iterable` now applies to
`dyn erased::Iterable`, but things still work out due to some
[language magic.](./dyn-trait-impls.md#the-implementation-cannot-be-directly-overrode)
The blanket implementations of `useful::Iterable` in the `useful` module gives
us implementations for `&dyn erased::Iterable` and `Box<dyn erased::Iterable>`,
so now we're good to go!
## Mindful implementations and their limitations
You may have noticed how we took care to avoid boxing the iterator when possible
by being mindful of how we implemented some of the methods, for example not
having a default body for `erased::Iterable::visit`, and then overriding the
the default body of `useful::Iterable::visit`. This can lead to better performance
but isn't necessarily critical, so long as you avoid things like accidental
infinite recursion.
How well did we do on this front?
[Let's take a look in the playground.](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=31dbe5ae8a7a6b7677ed942962424e03)
Hmm, perhaps not as well as we hoped! `<dyn erased::Iterable as useful::Iterable>::visit`
avoids the boxing as designed, but `Box<dyn erased::Iterable>`'s `visit` still boxes the
iterator.
Why is that? It is because the implementation for the `Box` is supplied by the `useful`
module, and that implementation uses the default body. In order to avoid the boxing,
[it would need to recurse to the underlying implementation instead.](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=02ae6370cdd7f7b5b1586e0281e090d2)
That way, the call to `visit` will "drill down" until the implementation for
`dyn erased::Iterable::visit`, which takes care to avoid the boxed iterator. Or
phrased another way, the recursive implementations "respects" any overrides of the
default function body by other implementors of `useful::Iterable`.
Since the original trait might not even be in your crate, this might be out of your
control. Oh well, so it goes; maybe submit a PR 🙂. In this particular case you
could take care to pass `&dyn erased::Iterable` by coding `&*boxed_erased_iterable`.
Or maybe it doesn't really matter enough to bother in practice for your use case.
## Real world examples
Perhaps the most popular crate to use this pattern is
[the `erased-serde` crate.](https://crates.io/crates/erased-serde)
Another use case is [working with `async`-esque traits,](https://smallcultfollowing.com/babysteps/blog/2021/10/15/dyn-async-traits-part-6/)
which tends to involve a lot of type erasure and unnameable types.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Understand function lifetime parameters
First, note that elided lifetimes in function signatures are invisible lifetime parameters on the function.
```rust
fn zed(s: &str) {}
```
```rust
// same thing
fn zed<'s>(s: &'s str) {}
```
When you have a lifetime parameter like this, the *caller* chooses the lifetime.
But the body of your function is opaque to the caller: they can only choose lifetimes *just longer* than your function body.
So when you have a lifetime parameter on your function (without any further bounds), the only things you know are
* It's longer than your function body
* You don't get to pick it, and it could be arbitrarily long (even `'static`)
* But it could be *just barely longer* than your function body too; you have to support both cases
And the main corollaries are
* You can't borrow locals for a caller-chosen lifetime
* You can't extend a caller-chosen lifetime to some other named lifetime in scope
* Unless there's some other outlives bound that makes it possible
---
Here's a couple of error examples related to function lifetime parameters:
```rust
fn long_borrowing_local<'a>(name: &'a str) {
let local = String::new();
let borrow: &'a str = &local;
}
fn borrowing_zed(name: &str) -> &str {
match name.len() {
0 => "Hello, stranger!",
_ => &format!("Hello, {name}!"),
}
}
```
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Invariance elsewhere
While behind a `&mut` is the most common place to first encounter invariance,
it's present elsewhere as well.
`Cell<T>` and `RefCell<T>` are also invariant in `T`.
Trait parameters are invariant too. As a result, lifetime-parameterized traits can be onerous to work with.
Additionally, if you have a bound like `T: Trait<U>`, `U` becomes invariant becase it's a type parameter of the trait.
If your `U` resolves to `&'x V`, the lifetime `'x` will be invariant too.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# `dyn Trait` examples
Here we provide some "recipes" for common `dyn Trait` implementation
patterns.
In the examples, we'll typically be working with `dyn Trait`, `Box<dyn Trait>`,
and so on for the sake of brevity. But note that in more practical code, there
is a good chance you would also need to provide implementations for
`Box<dyn Trait + Send + Sync>` or other variations across auto-traits. This
may be in place of implementations for `dyn Trait` (if you always need the
auto-trait bounds) or in addition to implementations for `dyn Trait`
(to provide maximum flexibility).
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# `&'a mut self` and `Self` aliasing more generally
`fn foo(&'a mut self)` is a red flag -- because if that `'a` wasn't declared on the function,
it's probably part of the `Self` struct. And if that's the case, this is a `&'a mut Thing<'a>`
in disguise. [As discussed in the previous section,](./pf-borrow-forever.md) this will make
`self` unusable afterwards, and thus is an anti-pattern.
More generally, `self` types and the `Self` alias include any parameters on the type constructor post-resolution.
[Which means here:](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=a46b294ec613acda99767069a744c488)
```rust
struct Node<'a>(&'a str);
impl<'a> Node<'a> {
fn new(s: &str) -> Self {
Node(s)
}
}
```
`Self` is an alias for `Node<'a>`. It is *not* an alias for `Node<'_>`. So it means:
```rust
fn new<'s>(s: &'s str) -> Node<'a> {
```
And not:
```rust
fn new<'s>(s: &'s str) -> Node<'s> {
```
And you really meant to code one of these:
```rust
fn new(s: &'a str) -> Self {
fn new(s: &str) -> Node<'_> {
```
Similarly, using `Self` as a constructor will use the resolved type parameters. So this won't work:
```rust
fn new(s: &str) -> Node<'_> {
Self(s)
}
```
You need
```rust
fn new(s: &str) -> Node<'_> {
Node(s)
}
```
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Understand elision and get a feel for when to name lifetimes
[Read the function lifetime elision rules.](https://doc.rust-lang.org/reference/lifetime-elision.html)
They're intuitive for the most part. The elision rules are built around being what you need in the common case,
but they're not always the solution. For example, they assume an input of `&'s self` means you mean to return a
borrow of `self` or its contents with lifetime `'s`, but this is often *not* correct for lifetime-carrying
data structures.
If you get a lifetime error involving elided lifetimes, try giving all the lifetimes names. This can improve
the compiler errors; if nothing else, you won't have to work so hard to mentally track the numbers used in
errors for illustration, or what "anonymous lifetime" is being talked about.
Take care to refer to the elision rules when naming all the lifetimes, or you may inadverently change the
meaning of the signature. If the error changes *drastically,* you've probably changed the meaning of the
siguature.
Once you have a good feel for the function lifetime elision rules, you'll start developing intuition for
when you need to name your lifetimes instead.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Learn some pitfalls and anti-patterns
Here we cover some pitfalls to recognize and anti-patterns to avoid.
First, [read this list of common lifetime misconceptions](https://github.com/pretzelhammer/rust-blog/blob/master/posts/common-rust-lifetime-misconceptions.md) by @pretzelhammer.
Skip or skim the parts that don't make sense to you yet, and return to it for a re-read occasionally.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# When not to name lifetimes
Sometimes newcomers try to solve borrow check errors by making things more generic,
which often involves adding lifetimes and naming previously-elided lifetimes:
```rust
# struct S; impl S {
fn quz<'a: 'b, 'b>(&'a mut self) -> &'b str { todo!() }
# }
```
But this doesn't actually permit more lifetimes than this:
```rust
# struct S; impl S {
fn quz<'b>(&'b mut self) -> &'b str { todo!() }
# }
```
Because in the first example, `&'a mut self` can coerce to `&'b mut self`.
And, in fact, you want it to -- because you generally don't want to exclusively borrow `self` any longer than necessary.
And at this point you can instead utilize lifetime elision and stick with:
```rust
# struct S; impl S {
fn quz(&mut self) -> &str { todo!() }
# }
```
As covariance and function lifetime elision become more intuitive, you'll build a feel for when it's
pointless to name lifetimes. Adding surpuflous lifetimes like in the first example tends to make
understanding borrow errors harder, not easier.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# `impl Trait for Box<dyn Trait>`
Let's look at how one implements `Trait for Box<dyn Trait + '_>`. One
thing to note off that bat is that most methods are going to involve
calling a method of the `dyn Trait` *inside* of our box, but if we just
use `self.method()` we would instantly recurse with the very method
we're writing (`<Box<dyn Trait>>::method`)!
***We need to take care to call `<dyn Trait>::method` and not `<Box<dyn Trait>>::method`
in those cases to avoid infinite recursion.***
Now that we've highlighted that consideration, let's dive right in:
```rust
trait Trait {
fn look(&self);
fn boop(&mut self);
fn bye(self) where Self: Sized;
}
impl Trait for Box<dyn Trait + '_> {
fn look(&self) {
// We do NOT want to do this!
// self.look()
// That would recursively call *this* function!
// We need to call `<dyn Trait as Trait>::look`.
// Any of the below forms work, it depends on
// how explicit you want to be.
// Very explicit
// <dyn Trait as Trait>::look(&**self)
// Yay auto-deref for function parameters
// <dyn Trait>::look(self)
// Very succinct and a "makes sense once you've
// seen it enough times" form. The first deref
// is for the reference (`&Self`) and the second
// deref is for the `Box<_>`.
(**self).look()
}
fn boop(&mut self) {
// This is similar to the `&self` case
(**self).boop()
}
fn bye(self) {
// Uh... see below
}
}
```
Oh yeah, that last one. [Remember what we said before?](dyn-trait-impls.md#boxdyn-trait-and-dyn-trait-do-not-automatically-implement-trait)
`dyn Trait` doesn't have this method, but `Box<dyn Trait + '_>` does.
The compiler isn't going to just guess what to do here (and couldn't if,
say, we needed a return value). We can't move the `dyn Trait` out of
the `Box` because it's unsized. And we can't
[downcast from `dyn Trait`](./dyn-any.md#downcasting-methods-are-not-trait-methods)
either; even if we could, it would rarely help here, as we'd have to both
impose a `'static` constraint and also know every type that implements our
trait to attempt downcasting on each one (or have some other clever scehme
for more efficient downcasting).
Ugh, no wonder `Box<dyn Trait>` doesn't implement `Trait` automatically.
Assuming we want to call `Trait::bye` on the erased type, are we out of luck?
No, there are ways to work around this:
```rust
// Supertrait bound
trait Trait: BoxedBye {
fn bye(self);
}
trait BoxedBye {
// Unlike `self: Self`, this does *not* imply `Self: Sized` and
// thus *will* be available for `dyn BoxedBye + '_`... and for
// `dyn Trait + '_` too, automatically.
fn boxed_bye(self: Box<Self>);
}
// We implement it for all `Sized` implementors of `trait: Trait` by
// unboxing and calling `Trait::bye`
impl<T: Trait> BoxedBye for T {
fn boxed_bye(self: Box<Self>) {
<Self as Trait>::bye(*self)
}
}
impl Trait for Box<dyn Trait + '_> {
fn bye(self) {
// This time we pass `self` not `*self`
<dyn Trait as BoxedBye>::boxed_bye(self);
}
}
```
By adding the supertrait bound, the compiler will supply an implementation of
`BoxedBye for dyn Trait + '_`. That implementation will call the implemenation
of `BoxedBye` for `Box<Erased>`, where `Erased` is the erased base type. That
is our blanket implementation, which unboxes `Erased` and calls `Erased`'s
`Trait::bye`.
The signature of `<dyn Trait as BoxedBye>::boxed_bye` has a receiver with the
type `Box<dyn Trait + '_>`, which is exactly the same signature as
`<Box<dyn Trait + '_> as Trait>::bye`. And that's how we were able to
complete the implementation of `Trait` for `Box<dyn Trait + '_>`.
Here's how things flow when calling `Trait::bye` on `Box<dyn Trait + '_>`:
```rust,ignore
<Box<dyn Trait>>::bye (_: Box<dyn Trait>) -- just passed -->
< dyn Trait >::boxed_bye(_: Box<dyn Trait>) -- via vtable -->
< Erased >::boxed_bye(_: Box< Erased >) -- via unbox -->
< Erased >::bye (_: Erased ) :)
```
There's rarely a reason to implement `BoxedBye for Box<dyn Trait + '_>`, since
that takes a nested `Box<Box<dyn Trait + '_>>` receiver.
Any `Sized` implementor of `Trait` will get our blanket implementation of
the `BoxedBye` supertrait "for free", so they don't have to do anything
special.
---
The last thing I'll point out is how we did
```rust
# trait Trait {}
impl Trait for Box<dyn Trait + '_> {
// this: ^^^^
# }
```
[We didn't need to require `'static`, so this is more flexible.](dyn-elision-basic.md#impl-headers)
It's also very easy to forget.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Reference lifetimes
Here's something you'll utilize in Rust all the time without thinking about it:
* A `&'long T` coerces to a `&'short T`
* A `&'long mut T` coerces to a `&'short mut T`
The technical term is "covariant (in the lifetime)" but a practical mental model is "the (outer) lifetime of references can shrink".
The property holds for values whose type is a reference, but it doesn't always hold for other types.
For example, we'll soon see that this property doesn't always hold for the lifetime of a reference
nested within another reference. When the property doesn't hold, it's usually due to *invariance*.
Even if you never really think about covariance, you'll grow an intuition for it -- so much for so
that you'll eventually be surprised when you encounter invariance and the property doesn't hold.
We'll look at some cases soon.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Generalizing borrows
A lot of core traits are built around some sort of *field projection,* where
the implementing type contains some other type `T` and you can convert a
`&self` to a `&T` or `&mut self` to a `&mut T`.
```rust
pub trait Deref {
type Target: ?Sized;
fn deref(&self) -> &Self::Target;
}
pub trait Index<Idx: ?Sized> {
type Output: ?Sized;
fn index(&self, index: Idx) -> &Self::Output;
}
pub trait AsRef<T: ?Sized> {
fn as_ref(&self) -> &T;
}
pub trait Borrow<Borrowed: ?Sized> {
fn borrow(&self) -> &Borrowed;
}
// `DerefMut`, `IndexMut`, `AsMut`, ...
```
There's generally no way to implement these traits if the type you want to
return is not contained within `Self` (except for returning a reference to
some static value or similar, which is rarely what you want).
However, sometimes you have a custom borrowing type which is *not*
actually contained within your owning type:
```rust
// We wish we could implement `Borrow<DataRef<'?>>`, but we can't
pub struct Data {
first: usize,
others: Vec<usize>,
}
pub struct DataRef<'a> {
first: usize,
others: &'a [usize],
}
pub struct DataMut<'a> {
first: usize,
others: &'a mut Vec<usize>,
}
```
This can be problematic when interacting with libraries and data structures
such as [`std::collections::HashSet`,](https://doc.rust-lang.org/std/collections/struct.HashSet.html)
which [rely on the `Borrow` trait](https://doc.rust-lang.org/std/collections/struct.HashSet.html#method.contains)
to be able to look up entries without taking ownership.
One way around this problem is to use
[a different library or type which is more flexible.](https://docs.rs/hashbrown/0.14.0/hashbrown/struct.HashSet.html#method.contains)
However, it's also possible to tackle the problem with a bit of indirection and type erasure.
## Your types contain a borrower
Here we present a solution to the problem by
[Eric Michael Sumner](https://orcid.org/0000-0002-6439-9757), who has
graciously blessed its inclusion in this guide. I've rewritten the
original for the sake of presentation, and any errors are my own.
The main idea behind the approach is to utilize the following trait, which
encapsulates the ability to borrow `self` in the form of your custom borrowed
type:
```rust
#pub struct Data { first: usize, others: Vec<usize> }
#pub struct DataRef<'a> { first: usize, others: &'a [usize] }
pub trait Lend {
fn lend(&self) -> DataRef<'_>;
}
impl Lend for Data {
fn lend(&self) -> DataRef<'_> {
DataRef {
first: self.first,
others: &self.others,
}
}
}
impl Lend for DataRef<'_> {
fn lend(&self) -> DataRef<'_> {
DataRef {
first: self.first,
others: self.others,
}
}
}
// impl Lend for DataMut<'_> ...
```
And the key insight is that any implementor can also coerce from
`&self` to `&dyn Lend`. We can therefore implement traits like
`Borrow`, because every implementor "contains" a `dyn Lend` --
themselves!
```rust
#pub struct Data { first: usize, others: Vec<usize> }
#pub struct DataRef<'a> { first: usize, others: &'a [usize] }
#pub trait Lend { fn lend(&self) -> DataRef<'_>; }
#impl Lend for Data {
# fn lend(&self) -> DataRef<'_> {
# DataRef {
# first: self.first,
# others: &self.others,
# }
# }
#}
#impl Lend for DataRef<'_> {
# fn lend(&self) -> DataRef<'_> {
# DataRef {
# first: self.first,
# others: self.others,
# }
# }
#}
use std::borrow::Borrow;
impl<'a> Borrow<dyn Lend + 'a> for Data {
fn borrow(&self) -> &(dyn Lend + 'a) { self }
}
impl<'a, 'b: 'a> Borrow<dyn Lend + 'a> for DataRef<'b> {
fn borrow(&self) -> &(dyn Lend + 'a) { self }
}
// impl<'a, 'b: 'a> Borrow<dyn Lend + 'a> for DataMut<'b> ...
```
This gives us a common `Borrow` type for both our owning and
custom borrowing data structures. To look up borrowed entries
in a `HashSet`, for example, we can cast a `&DataRef<'_>` to
a `&dyn Lend` and pass that to `set.contains`; the `HashSet` can
hash the `dyn Lend` and then borrow the owned `Data` entries as
`dyn Lend` as well, in order to do the necessary lookup
comparisons.
That means we need to implement the requisite functionality such as
`PartialEq` and `Hash` for `dyn Lend`. But this is a different use case
than [our general solution in the previous section.](./dyn-trait-eq.md)
In that case we wanted `PartialEq` for our already-type-erased `dyn Trait`,
so we could compare values across any arbitrary implementing types.
Here we don't care about arbitrary types, and we also have the ability
to produce a concrete type that references our actual data. We can
use that to implement the functionality; there's no need for downcasting
or any of that in order to implement the requisite traits for `dyn Lend`.
We don't really *care* that `dyn Lend` will implement `PartialEq` and
`Hash` per se, as that is just a means to an end: giving `HashSet` and
friends a way to compare our custom concrete borrowing types despite the
`Borrow` trait bound.
First things first though, we need our concrete types to implement
the requisite traits themselves. The main thing to be mindful of
is that we maintain
[the invariants expected by `Borrow`.](https://doc.rust-lang.org/std/borrow/trait.Borrow.html)
For this example, we're lucky enough that our borrowing
type can just derive all of the requisite functionality:
```rust
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub struct DataRef<'a> {
first: usize,
others: &'a [usize],
}
#[derive(Debug, Clone)]
pub struct Data {
first: usize,
others: Vec<usize>,
}
#[derive(Debug)]
pub struct DataMut<'a> {
first: usize,
others: &'a mut Vec<usize>,
}
```
However, we haven't derived the traits that are semantically important
to `Borrow` for our other types. We technically could have in
this case, because
- our fields are in the same order as they are in the borrowed type
- every field is present
- every field has a `Borrow` relationship when comparing with the borrowed type's field
- we understand how the `derive` works
But all those things might not be true for your use case, and even
when they are, relying on them creates a very fragile arrangement.
It's just too easy to accidentally break things by adding a field
or even just rearranging the field order.
Instead, we implement the traits directly by deferring to the borrowed type:
```rust
# struct Data; impl Data { fn lend(&self) {} }
// Excercise for the reader: `PartialEq` across all of our
// owned and borrowed types :-)
impl std::cmp::PartialEq for Data {
fn eq(&self, other: &Self) -> bool {
self.lend() == other.lend()
}
}
impl std::cmp::Eq for Data {}
impl std::hash::Hash for Data {
fn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {
self.lend().hash(hasher)
}
}
// Similarly for `DataMut<'_>`
```
And in fact, this is exactly the approach we want to take for
`dyn Lend` as well:
```rust
#pub struct DataRef<'a> { first: usize, others: &'a [usize] }
#pub trait Lend { fn lend(&self); }
impl std::cmp::PartialEq<dyn Lend + '_> for dyn Lend + '_ {
fn eq(&self, other: &(dyn Lend + '_)) -> bool {
self.lend() == other.lend()
}
}
impl std::cmp::Eq for dyn Lend + '_ {}
impl std::hash::Hash for dyn Lend + '_ {
fn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {
self.lend().hash(hasher)
}
}
```
Whew, that was a lot of boilerplate. But we're finally at a
place where we can store `Data` in a `HashSet` and look up
entries when we only have a `DataRef`:
```rust,ignore
use std::collections::HashSet;
let set = [
Data { first: 3, others: vec![5,7]},
].into_iter().collect::<HashSet<_>>();
assert!(set.contains::<dyn Lend>(&DataRef { first: 3, others: &[5,7]}))
// Alternative to turbofishing
let data_ref = DataRef { first: 3, others: &[5,7]};
assert!(set.contains(&data_ref as &dyn Lend));
```
[Here's a playground with the complete example.](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=cae538dbbf73e3e7692135bf2d397f39)
Another alternative to casting or turbofish is to add an
`as_lend(&self) -> &dyn Lend + '_` method, similar to many
of the previous examples.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# `dyn Trait` vs. alternatives
When getting familiar with Rust, it can be hard at first to
recognize when you should use `dyn Trait` versus some other
type mechanism, such as `impl Trait` or generics.
In this section we look at some tradeoffs, depending on the
use case.
## Generic functions and argument position `impl Trait`
### Preliminaries: What is argument position `impl Trait`?
When we talk about argument position `impl Trait`, aka APIT,
we're talking about functions such as this:
```rust
# use std::fmt::Display;
fn foo(d: impl Display) { println!("{d}"); }
// APIT: ^^^^^^^^^^^^
```
That is, `impl Trait` as an argument type of a function.
APIT is, so far at least, mostly the same as a generic parameter:
```rust
# use std::fmt::Display;
fn foo<D: Display>(d: D) { println!("{d}"); }
```
The main difference is that generics allow
- the function writer to refer to `D`
- e.g. `D::to_string(&d)`
- other utilizers to turbofish the function
- e.g. `let function_pointer = foo::<String>;`
Whereas the `impl Display` parameter is not nameable inside nor
outside the function.
There may be more differences in the future, but for now at least,
generics are the more flexible and thus superior form -- unless you
have a burning hatred against the `<...>` syntax, anyway.
At any rate, comparing `dyn Trait` against APIT is essencially the
same as comparing `dyn Trait` against a function with a generic type
parameter.
### Tradeoffs between generic functions and `dyn Trait`
Here, we're talking about choosing between signatures like so:
```rust
# trait Trait {}
// Owned or borrowed generics
fn foo1<T: Trait>(t: T) {}
fn bar1<T: Trait + ?Sized>(t: &T) {}
// Owned or borrowed `dyn Trait`
fn foo2(t: Box<dyn Trait + '_>) {}
fn bar2(t: &dyn Trait) {}
```
When a function has a generic parameter, the parameter is *monomorphized*
for every concrete type which is used to call the function (after lifetime
erasure). That is, every type the parameter takes on results in a distinct
function in the compiled code. (Some of the resulting functions may be
eliminated or combined by optimization if possible). There could be many
copies of `foo1` and `bar1`, depending on how it's called.
But (after lifetime erasure), `dyn Trait` is a singular concrete type.
There will only be one copy of `foo2` and `bar2`.
Yet in your typical Rust program, generic arguments are preferred over
`dyn Trait` arguments. Why is that? There are a number of reasons:
- Each monomorphized function can typically be optimized better
- Trait bounds are more general than `dyn Trait`
- No `dyn` safety concerns (`T: Clone` is possible)
- No single trait restriction (`T: Trait1 + Trait2` is allowed)
- Less indirection through dynamic dispatch
- No need for boxing in the owned case
- `Box` isn't even available in `#![no_std]` programs
The `dyn Trait` versions do have the following advantages:
- Smaller code size
- Faster code generation
- [Do not make traits `dyn`-unsafe](./dyn-trait-erased.md)
In general, you should prefer generics unless you have a specific
reason to opt for `dyn Trait` in argument position.
## Return position `impl Trait` and TAIT
### Preliminaries: What are return position `impl Trait` and TAIT?
When we talk about return position `impl Trait`, aka RPIT, we're talking
about functions such as this:
```rust
// RPIT: vvvvvvvvvvvvvvvvvvvvvvv
fn foo<T>(v: Vec<T>) -> impl Iterator<Item = T> {
v.into_iter().inspect(|t| println!("{t:p}"))
}
```
Unlike APIT, RPITs are not the same as a generic type parameter. They
are instead opaque type aliases or opaque type alias constructors. In
the above example, the RPIT is an opaque type alias constructor which
depends on the input type parameter of the function (`T`). For every
concrete `T`, the RPIT is also an alias of a ***singular*** concrete
type.
The function body and the compiler still know what the concrete type is,
but that is opaque to the caller and other code. Instead, the only ways
you can use the type are those which are compatible with the trait or
traits in the `impl Trait`, plus any auto traits which the concrete type
happens to implement.
The singular part is key: the following code does not compile because
it is trying to return two distinct types. Rust is strictly and
statically typed, so this is not possible -- the opacity of the RPIT
does not and cannot change that.
```rust,compile_fail
# use std::fmt::Display;
fn foo(b: bool) -> impl Display {
if b { 0 } else { "hi!" }
}
```
`type` alias `impl Trait`, or TAIT, is a generalization of RPIT which
[is not yet stable,](https://github.com/rust-lang/rust/issues/63063)
but may become stable before *too* much longer. TAIT allows one to
define aliases for opaque types, which allows them to be named and
to be used in more than one location.
```rust,nightly
#![feature(type_alias_impl_trait)]
type MyDisplay = impl std::fmt::Display;
fn foo() -> MyDisplay { "hello," }
fn bar() -> MyDisplay { " world" }
```
Notionally (and hopefully literally), RPIT desugars to a TAIT in
a manner similar to this:
```rust,nightly
#![feature(type_alias_impl_trait)]
# use std::fmt::Display;
fn foo1() -> impl Display { "hi" }
// Same thing... or so
type __Unnameable_Tait = impl Display;
fn foo2() -> __Unnameable_Tait { "hi" }
```
TAITs must still be an alias of a singular, concrete type.
### Tradeoffs between RPIT and `dyn Trait`
RPITs and `dyn Trait` returns share some benefits for the function writer:
- So long as the bounds don't change, you can change the concrete or base type
- You can return unnameable types, such as closures
- It simplifies complicated types, such as long iterator combinator chains
`dyn Trait` does have some limitations and downsides:
- Only one non-auto-trait is supportable without [subtype boilerplate](./dyn-trait-combining.md)
- In contrast, you can return `impl Trait1 + Trait2`
- Only `dyn`-safe traits are supportable
- In contrast, you can return `impl Clone`
- Boxing is required to returned owned types
- You pay the typical optimization penalties of not knowing the base type and performing dynamic dispatch
However, RPITs also have their downsides:
- As an opaque alias, you can only return one actual, concrete type
- For now, the return type is unnameable, which can be awkward for consumers
- e.g. you can't store the result as a field in your struct
- ...unless the opaque type bounds are `dyn`-safe and you can type erase it yourself
- Auto-traits are leaky, so it's easy for the function writer to accidentally break semver
- Whereas auto-traits are explicit with `dyn Trait`
- RPIT is not yet supported in traits
- It is planned ("RPITIT" (ugh)), but it is uncertain how far away the functionality is
RPITs also have some rather tricky behavior around type parameter and lifetime capture.
The planned `impl Trait` functionalities deserve their own exploration independent of
`dyn Trait`, so I'll only mention them in brief:
- RPIT captures all type parameters ([and their implied lifetimes](https://github.com/rust-lang/rust/issues/42940))
- RPIT captures specific lifetimes and not [the intersection of all lifetimes](./dyn-trait-lifetime.md#when-multiple-lifetimes-are-involved)
- And thus it is [tedious to capture an intersection of input lifetimes](https://github.com/danielhenrymantilla/fix_hidden_lifetime_bug.rs) instead of a union
Despite all these downsides, I would say that RPIT has a *slight* edge over `dyn Trait`
in return position *when applicable,* especially for owned types. The advantage between
`dyn Trait` and a (named) TAIT will be even greater, once that is available:
- You can give the return type a name
- You can be explicit about what type parameters are captured
- You can be more explicit about lifetime capture as well
- Though without a syntax for lifetime intersection, it will probably still be a pain to do so
But `dyn Trait` is still sometimes the better option:
- where RPIT is not supported, like in traits (so far)
- when you need to type erase and return distinct types
However, there is often a third possibility available, which we explore below:
return a generic struct.
### An alternative to both: nominal generic structs
Here we can take inspiration from the standard library. One of the more popular
situations to use RPIT or return `dyn Trait` is when dealing with iterators
(as iterator chains have long types and often involve unnameable types such as
closures as well).
[So let's look at the Iterator methods.](https://doc.rust-lang.org/std/iter/trait.Iterator.html)
You may notice a pattern with the combinators:
```rust,ignore
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
where
Self: Sized,
U: IntoIterator<Item = Self::Item>,
{ todo!() }
fn filter<P>(self, predicate: P) -> Filter<Self, P>
where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
{ todo!() }
fn map<B, F>(self, f: F) -> Map<Self, F>
where
Self: Sized,
F: FnMut(Self::Item) -> B,
{ todo!() }
```
The pattern is to have a function which is parameterized by a generic type
return a concrete (nominal) struct, also parameterized by the generic type.
This is possible even if the paramter itself is unnameable -- for example,
in the case of `map`, the `F: FnMut(Self::Item) -> B` parameter might well
be an unnameable closure.
The downside is much more boilerplate if you opt to follow this pattern
yourself: You have to define the struct, and (for examples like these)
implement the `Iterator` trait for them, and perhaps other traits such
as `DoubleEndedIterator` as desired. This will probably involve storing
the original iterator and calling `next().map(|item| ...)` on it, or
such.
The upside is that you (and the consumers of your method) get many of the upsides of both RPIT and `dyn Trait`:
- No dynamic dispatch penalty
- No boxing penalty
- No concrete-type specific optimzation loss
- No single trait limitation
- No `dyn`-safe limitation
- Applicable in traits
- Ability to be specific about captures
- Ability to change your implementation within the API bounds
- Nameable return type
You do retain some of the downsides:
- Auto-traits are leaky and still a semver hazard, as with RPIT
- Multiple concrete types aren't possible (without also utilizing type erasure), as with RPIT
And incur some unique ones as well:
- Variance of data types are leaky too
- Unnameable types that aren't input type parameters can't be supported (without also utilizing type erasure)
On the whole, when using a nominal type is possible, it is the best option for
consumers of the function. But it's also the most amount of work for the function
implementor.
I recommend nominal types for general libraries (i.e. intended for wide consumption)
when possible, following the lead of the standard library.
## Generic structs
In the last section, we covered how generic structs can often be used as an
alternative to RPIT or returning `dyn Trait` in some form. A related question
is, when should you use type erasure within your data types?
The main reason to use type erasure in your data types are when you want to
treat implementors of a trait as if they were the same type, for instance when
storing a collection of callbacks. In this case, the decision to use type
erasure is a question of functionality, and not really much of a choice.
However, you may also want to use type erasure in your data types in order
to make your own struct non-generic. When your data type is generic, after
all, those who use your data type in such a way that the parameter takes on
more than one type will have to propogate the use of generics themselves, or
face the decision of type erasing your data type themselves.
This can not only be a question of ergonomics, but also of compile time and
even run time performance. Compiling strictly more code by having all your
methods monomorphized will naturally tend to result in longer compile times,
and the increase in actual code size *can sometimes be slower at runtime*
than a touch of dynamic dispatch in the right areas.
Unfortunately, there is no silver bullet when it comes to choosing between
being generic and using type erasure. However, a general principle is that
your optimization sensitive, call-heavy code areas should not be type erased,
and instead push type erasure to a boundary outside of your heavy computations.
For example, the failure to devirtualize and inline a call to
`<dyn Iterator>::next` in a tight loop may have a relatively large impact,
whereas a dynamic callback that only fires occasionally (and then dispatches
to the optimized, non-type-erased implementation) is not likely to be
noticable at all.
## `enum`s
Finally we'll mention one other alternative to type erasure:
just put all of the implementing types in an `enum`!
This clearly only applies when you have a fixed set of types that you
expect to implement your trait. The downside of using an `enum` is that
it can involve a lot of boilerplate, since you're frequently having to check
which variant you are instead of relying on dynamic dispatch to perform
that function for you.
The upside is avoiding practically all of the downsides of type erasure
and the other alternatives such as opaque types.
Macros can help ease the pain of such boilerplate, and there are also
[crates in the ecosystem](https://crates.io/crates/ambassador) aimed at
reducing the boilerplate.
In fact, [there are also crates for this pattern as a whole.](https://crates.io/crates/enum_dispatch)
In particular, if you find yourself in a situation where you've
[chosen to use `dyn Any`](./dyn-any.md) but you find yourself with
a bunch of attempted downcasts against a known set of types, you
should *strongly* consider just using an `enum`. It won't be much
less ergonomic (if at all) and will be more efficient.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Get a feel for borrow-returning methods
Here we look at how borrow-returning methods work. Our examples will consider a typical
pattern:
```rust
fn method(&mut self) -> &SomeReturnType {}
```
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# `dyn Trait` Overview
## What is `dyn Trait`?
`dyn Trait` is a compiler-provided type which implements `Trait`. Any `Sized` implementor
of `Trait` can be coerced to be a `dyn Trait`, erasing the original base type in the process.
Different implementations of `Trait` may have different sizes, and as a result, `dyn Trait`
has no statically known size. That means it does not implement `Sized`, and we call such
types "unsized", or "dynamically sized types (DSTs)".
Every `dyn Trait` value is the result of type erasing some other existing value.
You cannot create a `dyn Trait` from a trait definition alone; there must be an
implementing base type that you can coerce.
Rust currently does not support passing unsized parameters, returning unsized values, or
having unsized locals. Therefore, when interacting with `dyn Trait`, you will generally
be working with some sort of indirection: a `Box<dyn Trait>`, `&dyn Trait`, `Arc<dyn Trait>`,
etc.
And in fact, the indirection is necessary for another reason. These indirections are or
contain *wide pointers* to the erased type, which consist of a pointer to the value, and
a second pointer to a static *vtable*. The vtable in turn contains data such as the size
of the value, a pointer to the value's destructor, pointers to methods of the `Trait`,
and so on. The vtable [enables dynamic dispatch,](./dyn-trait-impls.md) by which
different `dyn Trait` values can dispatch method calls to the different erased base type
implementations of `Trait`.
`dyn Trait` is also called a "trait object".
You can also have objects such as `dyn Trait + Send + Sync`. `Send` and `Sync` are
[auto-traits,](https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits)
and a trait object can include any number of these auto traits as additional bounds.
Every distinct set of `Trait + AutoTraits` is a distinct type.
However, you can only have one *non*-auto trait in a trait object, so this will not
work:
```rust,compile_fail
trait Trait1 {}
trait Trait2 {};
struct S(Box<dyn Trait1 + Trait2>);
```
That being noted, [one can usually use a subtrait/supertrait pattern](./dyn-trait-combining.md)
to work around this restriction.
### The trait object lifetime
Confession: we were being imprecise when we said `dyn Trait` is a type. `dyn Trait` is a
*type constructor*: [it is parameterized with a lifetime,](./dyn-trait-lifetime.md)
similar to how references are. So `dyn Trait` on it's own isn't a type,
`dyn Trait + 'a` for some concrete lifetime `'a` is a type.
The lifetime can usually be elided, [which we will explore later.](./dyn-elision.md)
But it is always part of the type,
[just like a lifetime is part of every reference type,](./st-types.md)
even when elided.
### Associated Types
If a trait has non-generic associated types, those associated types become
named parameters of `dyn Trait`:
```rust
let _: Box<dyn Iterator<Item = i32>> = Box::new([1, 2, 3].into_iter());
```
We explore this some more [in a later section.](./dyn-trait-coercions.md#associated-types)
## What `dyn Trait` is *not*
### `dyn Trait` is not `Sized`
We mentioned the fact that `dyn Trait` is not `Sized` already.
However, let us take a moment to note that generic parameters
[have an implicit `Sized` bound.](https://doc.rust-lang.org/reference/special-types-and-traits.html#sized)
Therefore you may need to remove the implicit bound by using
`: ?Sized` in order to use `dyn Trait` in generic contexts.
```rust,compile_fail
# trait Trait {}
// This function only takes `T: Sized`. It cannot accept a
// `&dyn Trait`, for example, as `dyn Trait` is not `Sized`.
fn foo<T: Trait>(_: &T) {}
// This function takes any `T: Trait`, even if `T` is not
// `Sized`.
fn bar<T: Trait + ?Sized>(t: &T) {
// Demonstration that `foo` cannot except non-`Sized`
// types:
foo(t);
}
```
### `dyn Trait` is neither a generic nor dynamically typed
Given a concrete lifetime `'a`, `dyn Trait + 'a` is a statically known type.
The *erased base type* is not statically known, but don't let this confuse
you: the `dyn Trait` itself is its own distinct type and that type is known
at compile time.
For example, consider these two function signatures:
```rust
# trait Trait {}
fn generic<T: Trait>(_rt: &T) {}
fn not_generic(_dt: &dyn Trait) {}
```
In the generic case, a distinct version of the function will exist for every
type `T` which is passed to the function. This compile-time generation of
new functions for every type is known as monomorphization. (Side note,
lifetimes are erased during compilation, and not monomorphized.)
You can even create function pointers to the different versions like so:
```rust
# trait Trait {}
# impl Trait for String {}
# fn generic<T: Trait>(_rt: &T) {}
# fn main() {
let fp = generic::<String>;
# }
```
That is, the function item type is parameterized by some `T: Trait`.
In contrast, there will always only be only one `non_generic` function in
the resulting library. The base implementors of `Trait` must be typed-erased
into `dyn Trait + '_` before being passed to the function. The function type
is not parameterized by a generic type.
Similarly, here:
```rust
# trait Trait {}
fn generic<T: Trait>(bx: Box<T>) {}
```
`bx: Box<T>` is not a `Box<dyn Trait>`. It is a thin owning pointer to a
heap allocated `T` specifically. Because `T` has an implicit `Sized` bound
here, we could *coerce* `bx` to a `Box<dyn Trait + '_>`. But that would be a
transformation to a different type of `Box`: a wide owning pointer which has
erased `T` and included the corresponding vtable pointer.
We'll explore more details on the interaction of generics and `dyn Trait`
[in a later section.](./dyn-trait-vs.md)
You may wonder why you can use the methods of `Trait` on a `&dyn Trait` or
`Box<dyn Trait>`, etc., despite not declaring any such bound. The reason is
analogous to why you can use `Display` methods on a `String` without declaring
that bound, say: the type is staically known, and the compiler recognizes that
`dyn Trait` implements `Trait`, just like it recognizes that `String`
implements `Display`. Trait bounds are needed for generics, not concrete types.
(In fact, [`Box<dyn Trait>` doesn't implement `Trait` automatically,](./dyn-trait-impls.md#boxdyn-trait-and-dyn-trait-do-not-automatically-implement-trait)
but deref coercion usually takes care of that case. For many `std` traits,
the trait is explicitly implemented for `Box<dyn Trait>` as well;
[we'll also explore what that can look like.](./dyn-trait-box-impl.md))
As a concrete type, you can also implement methods on `dyn Trait`
(provided `Trait` is local to your crate), and even implement *other*
traits for `dyn Trait`
(as we will see in [some of the examples](./dyn-trait-examples.md)).
### `dyn Trait` is not a supertype
Because you can coerce base types into a `dyn Trait`, it is not uncommon for
people to think that `dyn Trait` is some sort of supertype over all the
coercible implementors of `Trait`. The confusion is likely exacerbated by
trait bounds and lifetime bounds sharing the same syntax.
But the coercion from a base type to a `dyn Trait` is an unsizing coercion,
and not a sub-to-supertype conversion; the coercion happens at statically
known locations in your code, and may change the layout of the types
involved (e.g. changing a thin pointer into a wide pointer) as well.
Relatedly, `trait Trait` is not a class. You cannot create a `dyn Trait`
without an implementing type (they do not have built-in constructors),
and a given type can implement a great many traits. Due to the confusion it
can cause, I recommend not referring to base types as "instances" of the trait.
It is just a type that implements `Trait`, which exists independently of the
trait. When I create a `String`, I'm creating a `String`, not "an instance
of `Display` (and `Debug` and `Write` and `ToString` and ...)".
When I read "an instance of `Trait`", I assume the variable in question is
some form of `dyn Trait`, and not some unerased base type that implements `Trait`.
Implementing something for `dyn Trait` does not implement it for all other
`T: Trait`. In fact it implements it for nothing but `dyn Trait` itself.
Implementing something for `dyn Trait + Send` doesn't implement anything
for `dyn Trait` or vice-versa either; those are also separate, distinct types.
There are ways to *emulate* dynamic typing in Rust, [which we will explore later.](./dyn-any.md)
We'll also explore the role of [*supertraits*](./dyn-trait-combining.md) (which, despite the
name, still do not define a sub/supertype relationship).
The *only* subtypes in Rust involve lifetimes and types which are
higher-ranked over lifetimes.
<small>(Pedantic self-correction: trait objects have lifetimes and thus [are supertypes in that sense.](./dyn-covariance.md) However that's not the same concept that most Rust learners get confused about; there is no supertype relationship with the implementing types.)</small>
### `dyn Trait` is not universally applicable
We'll look at the details in their own sections, but in short, you cannot
always coerce an implementor of `Trait` into `dyn Trait`. Both
[the trait](./dyn-safety.md) and [the implementor](dyn-trait-coercions.md)
must meet certain conditions.
## In summary
`dyn Trait + 'a` is
* a concrete, statically known type
* created by type erasing implementors of `Trait`
* used behind wide pointers to the type-erased value and to a static vtable
* dynamically sized (unsized, does not implement `Sized`)
* an implementor of `Trait` via dynamic dispatch
* *not* a supertype of all implementors
* *not* dynamically typed
* *not* a generic
* *not* creatable from all values
* *not* available for all traits
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Basic guidelines and subtleties
As a reminder, `dyn Trait` is a type constructor which is parameterized with a
lifetime; a fully resolved type includes the lifetime, such as `dyn Trait + 'static`.
The lifetime can be elided in many sitations, in which case the actual lifetime
used may take on some default lifetime, or may be inferred.
When talking about default trait object (`dyn Trait`) lifetimes, we're talking about
situations where the lifetime has been completely elided. If the wildcard lifetime
is used (`dyn Trait + '_`), then [the normal lifetime elision rules](https://doc.rust-lang.org/reference/lifetime-elision.html#lifetime-elision-in-functions)
usually apply instead. (The exceptions are rare, and you can usually be explicit
instead if you need to.)
For a completely elided `dyn Trait` lifetime, you can start with these
general guidelines for traits with no lifetime bounds (which are the vast majority):
- In function bodies, the trait object lifetime is inferred (i.e. ignore the following bullets)
- For references like `&'a dyn Trait`, the default is the same as the reference lifetime (`'a`)
- For `dyn`-supporting `std` types with lifetime parameters such as
[`Ref<'a, T>`](https://doc.rust-lang.org/std/cell/struct.Ref.html), it is also `'a`
- For non-lifetime-parameter types like `Box<dyn Trait>`, and for bare `dyn Trait`, it's `'static`
And for the (rare) trait with lifetime bounds:
- If the trait has a `'static` bound, the trait object lifetime is always `'static`
- If the trait has only non-`'static` lifetime bounds, [you're better off being explicit](./dyn-elision-trait-bounds.md)
This is a close enough approximation to let you understand `dyn Trait`
lifetime elision most of the time, but there are exceptions to these
guidelines (which are explored on the next couple of pages).
There are also a few subtleties worth pointing out *within* these guidelines,
which are covered immediately below.
## Default `'static` bound gotchas
The most likely scenario to run into an error about `dyn Trait` lifetime is
when `Box` or similar is involved, resulting an implicit `'static` constraint.
Those errors can often be addressed by either adding an explicit `'static`
bound, or by overriding the implicit `'static` lifetime. In particular, using
`'_` will usually result in the "normal" (non-`dyn Trait`) lifetime elision for
the given context.
```rust
trait Trait {}
impl<T: Trait> Trait for &T {}
// Remove `+ 'static` to see an error
fn with_explicit_bound<'a, T: Trait + 'static> (t: T) -> Box<dyn Trait> {
Box::new(t)
}
// Remove `+ 'a` (in either position) to see an error
fn with_nonstatic_box<'a, T: Trait + 'a>(t: T) -> Box<dyn Trait + 'a> {
Box::new(t)
}
// Remove `+ '_` to see an error
fn with_fn_lifetime_elision(t: &impl Trait) -> Box<dyn Trait + '_> {
Box::new(t)
}
```
This can be particularly confusing within a function body, where a
`Box<dyn Trait>` variable annotation acts differently from a `Box<dyn Trait>`
function input parameter annotation:
```rust
# trait Trait {}
# impl Trait for &i32 {}
// In this context, the elided lifetime is `'static`
fn requires_static(_: Box<dyn Trait>) {}
fn example() {
let local = 0;
// In this context, the annotation means `Box<dyn Trait + '_>`!
// That is why it can compile on it's own, with the local reference.
let bx: Box<dyn Trait> = Box::new(&local);
// So despite using the same syntax, this call cannot compile.
// Uncomment it to see the compilation error.
// requires_static(bx);
}
```
## `impl` headers
The `dyn Trait` lifetime elision applies in `impl` headers, which can lead to
implementations being less general than possible or desired:
```rust
trait Trait {}
trait Two {}
impl Two for Box<dyn Trait> {}
impl Two for &dyn Trait {}
```
`Two` is implemented for
- `Box<dyn Trait + 'static>`
- `&'a (dyn Trait + 'a)` for any `'a` (the lifetimes must match)
Consider using implementations like the following if possible, as they are
more general:
```rust
# trait Trait {}
# trait Two {}
// Implemented for all lifetimes
impl Two for Box<dyn Trait + '_> {}
// Implemented for all lifetimes such that the inner lifetime is
// at least as long as the outer lifetime
impl Two for &(dyn Trait + '_) {}
```
## Alias gotchas
Similar to `impl` headers, elision will apply when defining a type alias:
```rust,compile_fail
trait MyTraitICouldNotThinkOfAShortNameFor {}
// This is an alias to `dyn ... + 'static`!
type MyDyn = dyn MyTraitICouldNotThinkOfAShortNameFor;
// The default does not "override" the type alias and thus
// requires the trait object lifetime to be `'static`
fn foo(_: &MyDyn) {}
// As per the `dyn` elision rules, this requires the trait
// object lifetime to be the same as the reference...
fn bar(d: &dyn MyTraitICouldNotThinkOfAShortNameFor) {
// ...and thus this fails as the lifetime cannot be extended
foo(d);
}
```
More generally, elision does not "penetrate" or alter type aliases.
This includes the `Self` alias within implementation blocks.
```rust,compile_fail
trait Trait {}
impl dyn Trait {
// Error: requires `T: 'static`
fn f<T: Trait>(t: &T) -> &Self { t }
}
impl<'a> dyn Trait + 'a {
// Error: requires `T: 'a`
fn g<T: Trait>(t: &T) -> &Self { t }
}
```
See also [how type aliases with parameters behave.](./dyn-elision-advanced.md#iteraction-with-type-aliases)
## `'static` traits
When the trait itself is `'static`, the trait object lifetime has an implied
`'static` bound. Therefore if you name the trait object lifetime explicitly,
the name you give it will also have an implied `'static` bound. So here:
```rust,compile_fail
# use core::any::Any;
// n.b. trait `Any` has a `'static` bound
fn example<'a>(_: &'a (dyn Any + 'a)) {}
fn main() {
let local = ();
example(&local);
}
```
We get an error that the borrow of `local` must be `'static`. The problem is
that `'a` in `example` has inherited the `'static` bound (`'a: 'static`), and
we also gave the outer reference the lifetime of `'a`. This is a case where
we don't actually want them to be the same.
The most ergonomic solution is to always completely elide the trait object
lifetime when the trait itself has a `'static` bound. Unlike other cases,
the trait object lifetime is independent of the outer reference lifetime when
the trait itself has a `'static` bound, so this compiles:
```rust
# use core::any::Any;
// This is `&'a (dyn Any + 'static)` and `'a` doesn't have to be `'static`
fn example(_: &dyn Any) {}
fn main() {
let local = ();
example(&local);
}
```
`Any` is the most common trait with a `'static` bound, i.e. the most likely
reason for you to encounter this scenario.
## `static` contexts
In some contexts like when declaring a `static`, it's possible to elide the
lifetime of types like references; doing so will result in `'static` being
used for the elided lifetime:
```rust
// The elided lifetime is `'static`
static S: &str = "";
const C: &str = "";
```
As a result, elided `dyn Trait` lifetimes will by default also be `'static`,
matching the inferred lifetime of the reference. In contrast, this fails
due to the outer lifetime being `'static`:
```rust,compile_fail
# trait Trait {}
# impl Trait for () {}
struct S<'a: 'b, 'b>(&'b &'a str);
impl<'a: 'b, 'b> S<'a, 'b> {
const T: &(dyn Trait + 'a) = &();
}
```
In this context, eliding all the lifetimes is again *usually* what you want.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Prefer ownership over long-lived references
A common newcomer mistake is to overuse references or other lifetime-carrying
data structures by storing them in their own long-lived structures. This is
often a mistake as the primary use-case of non-`'static` references is for
short-term borrows.
If you're trying to create a lifetime-carrying struct, stop and consider if
you could use a struct with no lifetime instead, for example by replacing
`&str` with `String`, or `&[T]` with `Vec<T>`.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Higher-ranked types
Another feature of trait objects is that they can be *higher-ranked* over
lifetime parameters of the trait:
```rust
// A trait with a lifetime parameter
trait Look<'s> {
fn method(&self, s: &'s str);
}
// An implementation that works for any lifetime
impl<'s> Look<'s> for () {
fn method(&self, s: &'s str) {
println!("Hi there, {s}!");
}
}
fn main() {
// A higher-ranked trait object
// vvvvvvvvvvvvvvvvvvvvvvvv
let _bx: Box<dyn for<'any> Look<'any>> = Box::new(());
}
```
The `for<'x>` part is a *lifetime binder* that introduces higher-ranked
lifetimes. There can be more than one lifetime, and you can give them
arbitrary names just like lifetime parameters on functions, structs,
and so on.
You can only coerce to a higher-ranked trait object if you implement
the trait in question for *all* lifetimes. For example, this doesn't
work:
```rust,compile_fail
# trait Look<'s> { fn method(&self, s: &'s str); }
impl<'s> Look<'s> for &'s i32 {
fn method(&self, s: &'s str) {
println!("Hi there, {s}!");
}
}
fn main() {
let _bx: Box<dyn for<'any> Look<'any>> = Box::new(&0);
}
```
`&'s i32` only implements `Look<'s>`, not `Look<'a>` for all lifetimes `'a`.
Similarly, this won't work either:
```rust,compile_fail
# trait Look<'s> { fn method(&self, s: &'s str); }
impl Look<'static> for i32 {
fn method(&self, s: &'static str) {
println!("Hi there, {s}!");
}
}
fn main() {
let _bx: Box<dyn for<'any> Look<'any>> = Box::new(0);
}
```
Implementing the trait with `'static` as the lifetime parameter is not the
same thing as implementing the trait for any lifetime as the parameter.
Traits and trait implementations don't have something like variance; the
parameters of traits are always invariant and thus implementations are
always for the explicit lifetime(s) only.
## Subtyping
There's a relationship between higher-ranked types like `dyn for<'any> Look<'any>`
and non-higher-ranked types like `dyn Look<'x>` (for a single lifetime `'x`): the
higher-ranked type is a subtype of the non-higher-ranked types. Thus you can
coerce a higher-ranked type to a non-higher-ranked type with any concrete lifetime:
```rust
# trait Look<'s> { fn method(&self, s: &'s str); }
fn as_static(bx: Box<dyn for<'any> Look<'any>>) -> Box<dyn Look<'static>> {
bx
}
fn as_whatever<'w>(bx: Box<dyn for<'any> Look<'any>>) -> Box<dyn Look<'w>> {
bx
}
```
Note that this still isn't a form of variance for the *lifetime parameter* of the
trait. This fails for example, because you can't coerce from `dyn Look<'static>`
to `dyn Look<'w>`:
```rust
# trait Look<'s> { fn method(&self, s: &'s str); }
# fn as_static(bx: Box<dyn for<'any> Look<'any>>) -> Box<dyn Look<'static>> { bx }
fn as_whatever<'w>(bx: Box<dyn for<'any> Look<'any>>) -> Box<dyn Look<'w>> {
as_static(bx)
}
```
As a supertype coercion, going from higher-ranked to non-higher-ranked can
apply even in a covariant nested context,
[just like non-higher-ranked supertype coercions:](./dyn-covariance.md#variance-in-nested-context)
```rust
# trait Look<'s> {}
fn foo<'l: 's, 's, 'p>(v: *const Box<dyn for<'any> Look<'any> + 'l>) -> *const Box<dyn Look<'p> + 's> {
v
}
```
## `Fn` traits and `fn` pointers
The `Fn` traits ([`FnOnce`](https://doc.rust-lang.org/std/ops/trait.FnOnce.html),
[`FnMut`](https://doc.rust-lang.org/std/ops/trait.FnMut.html),
and [`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html))
have special-cased syntax. For one, you write them out to look more like
a function, using `(TypeOne, TypeTwo)` to list the input parameters and
`-> ResultType` to list the associated type. But for another, elided
input lifetimes are sugar that introduces higher-ranked bindings.
For example, these two trait object types are the same:
```rust
fn identity(bx: Box<dyn Fn(&str)>) -> Box<dyn for<'any> Fn(&'any str)> {
bx
}
```
This is similar to how elided lifetimes work for function declarations
as well, and indeed, the same output lifetime elision rules also apply:
```rust
// The elided input lifetime becomes a higher-ranked lifetime
// The elided output lifetime is the same as the single input lifetime
// (underneath the binder)
fn identity(bx: Box<dyn Fn(&str) -> &str>) -> Box<dyn for<'any> Fn(&'any str) -> &'any str> {
bx
}
```
```rust,compile_fail
// Doesn't compile as what the output lifetime should be is
// considered ambiguous
fn ambiguous(bx: Box<dyn Fn(&str, &str) -> &str>) {}
// Here's a possible fix, which is also an example of
// multiple lifetimes in the binder
fn first(bx: Box<dyn for<'a, 'b> Fn(&'a str, &'b str) -> &'a str>) {}
```
Function pointers are another example of types which can be higher-ranked
in Rust. They have analogous syntax and sugar to function declarations
and the `Fn` traits.
```rust
fn identity(fp: fn(&str) -> &str) -> for<'any> fn(&'any str) -> &'any str {
fp
}
```
### Syntactic inconsistencies
There are some inconsistencies around the syntax for function declarations,
function pointer types, and the `Fn` traits involving the "names" of the
input arguments.
First of all, only function (method) declarations can make use of the
shorthand `self` syntaxes for receivers, like `&self`:
```rust
# struct S;
impl S {
fn foo(&self) {}
// ^^^^^
}
```
This exception is pretty unsurprising as the `Self` alias only exists
within those implementation blocks.
Each non-`self` argument in a function declaration is an
[irrefutable pattern](https://doc.rust-lang.org/reference/items/functions.html#function-parameters)
followed by a type annotation. It is an error to leave out the pattern;
if you don't use the argument (and thus don't need to name it), you
still need to use at least the wildcard pattern.
```rust,compile_fail
fn this_works(_: i32) {}
fn this_fails(i32) {}
```
There is
[an accidental exception](https://rust-lang.github.io/rfcs/1685-deprecate-anonymous-parameters.html)
to this rule, but it was removed in Edition 2018 and thus is only
available on Edition 2015.
In contrast, each argument in a function pointer can be
- An *identifier* followed by a type annotation (`i: i32`)
- `_` followed by a type annotation (`_: i32`)
- Just a type name (`i32`)
So these all work:
```rust
let _: fn(i32) = |_| {};
let _: fn(i: i32) = |_| {};
let _: fn(_: i32) = |_| {};
```
But *actual* patterns [are not allowed:](https://doc.rust-lang.org/stable/error_codes/E0561.html)
```rust,compile_fail
let _: fn(&i: &i32) = |_| {};
```
The idiomatic form is to just use the type name.
It's also allowed [to have colliding names in function pointer
arguments,](https://github.com/rust-lang/rust/issues/33995) but this
is a property of having no function body -- so it's also possible in
a trait method declaration, for example. It is also related to the
Edition 2015 exception for anonymous function arguments mentioned
above, and may be deprecated eventually.
```rust
trait Trait {
fn silly(a: u32, a: i32);
}
let _: fn(a: u32, a: i32) = |_, _| {};
```
Finally, each argument in the `Fn` traits can *only* be a type name:
no identifiers, `_`, or patterns allowed.
```rust,compile_fail
// None of these compile
let _: Box<dyn Fn(i: i32)> = Box::new(|_| {});
let _: Box<dyn Fn(_: i32)> = Box::new(|_| {});
let _: Box<dyn Fn(&_: &i32)> = Box::new(|_| {});
```
Why the differences? One reason is that
[patterns are gramatically incompatible with anonymous arguments,
apparently.](https://github.com/rust-lang/rust/issues/41686#issuecomment-366611096)
I'm uncertain as to why identifiers are accepted on function pointers,
however, or more generally why the `Fn` sugar is inconsistent with
function pointer types. But the simplest explanation is that function
pointers existed first with nameable parameters for whatever reason,
whereas the `Fn` sugar is for trait input type parameters which also
do not have names.
## Higher-ranked trait bounds
You can also apply higher-ranked trait bounds (HRTBs) to generic
type parameters, using the same syntax:
```rust
# trait Look<'s> { fn method(&self, s: &'s str); }
fn box_it_up<'t, T>(t: T) -> Box<dyn for<'any> Look<'any> + 't>
where
T: for<'any> Look<'any> + 't,
{
Box::new(t)
}
```
The sugar for `Fn` like traits applies here as well. You've probably
already seen bounds like this on methods that take closures:
```rust
# struct S;
# impl S {
fn map<'s, F, R>(&'s self, mut f: F) -> impl Iterator<Item = R> + 's
where
F: FnMut(&[i32]) -> R + 's
{
// This part isn't the point ;-)
[].into_iter().map(f)
}
# }
```
That bound is actually `F: for<'x> FnMut(&'x [i32]) -> R + 's`.
## That's all about higher-ranked types for now
Hopefully this has given you a decent overview of higher-ranked
types, HRTBs, and how they relate to the `Fn` traits. There
are a lot more details and nuances to those topics and related
concepts such as closures, as you might imagine. However, an
exploration of those topics deserves its own dedicated guide, so
we won't see too much more about higher-ranked types in this
tour of `dyn Trait`.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Understand borrows within a function
The analysis that the compiler does to determine lifetimes and borrow check
*within* a function body is quite complicated. A full exploration is beyond
the scope of this guide, but we'll give a brief introduction here.
Your best bet if you run into an error you can't understand is to
ask for help on the forum or elsewhere.
## Borrow errors within a function
Here are some simple causes of borrow check errors within a function.
### Recalling the Basics
The most basic mechanism to keep in mind is that `&mut` references are exclusive,
while `&` references are shared and implement `Copy`. You can't intermix using
a shared reference and an exclusive reference to the same value, or two exclusive
references to the same value.
```rust
# fn main() {
let mut local = "Hello".to_string();
// Creating and using a shared reference
let x = &local;
println!("{x}");
// Creating and using an exclusive reference
let y = &mut local;
y.push_str(", world!");
// Trying to use the shared reference again
println!("{x}");
# }
```
This doesn't compile because as soon as you created the exclusive reference,
any other existing references must cease to be valid.
### Borrows are often implicit
Here's the example again, only slightly rewritten.
```rust
# fn main() {
let mut local = "Hello".to_string();
// Creating and using a shared reference
let x = &local;
println!("{x}");
// Implicitly creating and using an exclusive reference
local.push_str(", world!");
// Trying to use the shared reference again
println!("{x}");
# }
```
Here, [`push_str` takes `&mut self`,](https://doc.rust-lang.org/std/string/struct.String.html#method.push_str)
so an implicit `&mut local` exists as part of the method call,
and thus the example can still not compile.
### Creating a `&mut` is not the only exclusive use
The borrow checker looks at *every* use of a value to see if it's
compatible with the lifetimes of borrows to that value, not
just uses that involve references or just uses that involve lifetimes.
For example, moving a value invalidates any references to the
value, as otherwise those references would dangle.
```rust
# fn main() {
let local = "Hello".to_string();
// Creating and using a shared reference
let x = &local;
println!("{x}");
// Moving the value
let _local = local;
// Trying to use the shared reference again
println!("{x}");
# }
```
### Referenced values must remain in scope
The effects of a value going out of scope are similar to moving the
value: all references are invalidated.
```rust
# fn main() {
let x;
{
let local = "Hello".to_string();
x = &local;
} // `local` goes out of scope here
// Trying to use the shared reference after `local` goes out of scope
println!("{x}");
# }
```
### Using `&mut self` or `&self` counts as a use of all fields
In the example below, `left` becomes invalid when we create `&self`
to call `bar`. Because you can get a `&self.left` out of a `&self`,
this is similar to trying to intermix `&mut self.left` and `&self.left`.
```rust
#[derive(Debug)]
struct Pair {
left: String,
right: String,
}
impl Pair {
fn foo(&mut self) {
let left = &mut self.left;
left.push_str("hi");
self.bar();
println!("{left}");
}
fn bar(&self) {
println!("{self:?}");
}
}
```
More generally, creating a `&mut x` or `&x` counts as a use of
everything reachable from `x`.
## Some things that compile successfully
Once you've started to get the hang of borrow errors, you might start to
wonder why certain programs are *allowed* to compile. Here we introduce
some of the ways that Rust allows non-trivial borrowing while still being
sound.
### Independently borrowing fields
Rust tracks borrows of struct fields individually, so the borrows of
`left` and `right` below do not conflict.
```rust
# #[derive(Debug)]
# struct Pair {
# left: String,
# right: String,
# }
#
impl Pair {
fn foo(&mut self) {
let left = &mut self.left;
let right = &mut self.right;
left.push_str("hi");
right.push_str("there");
println!("{left} {right}");
}
}
```
This capability is also called [splitting borrows.](https://doc.rust-lang.org/nomicon/borrow-splitting.html)
Note that data you access through indexing are not consider fields
per se; instead indexing is [an operation that generally borrows
all of `&self` or `&mut self`.](https://doc.rust-lang.org/std/ops/trait.Index.html)
```rust
# fn main() {
let mut v = vec![0, 1, 2];
// These two do not overlap, but...
let left = &mut v[..1];
let right = &mut v[1..];
// ...the borrow checker cannot recognize that
println!("{left:?} {right:?}");
# }
```
Usually in this case, one uses methods like [`split_at_mut`](https://doc.rust-lang.org/std/primitive.slice.html#method.split_at_mut)
in order to split the borrows instead.
Similarly to indexing, when you access something through "deref coercion", you're
excercising [the `Deref` trait](https://doc.rust-lang.org/std/ops/trait.Deref.html)
(or `DerefMut`), which borrow all of `self`.
There are also some niche cases where the borrow checker is smarter, however.
```rust
# fn main() {
// Pattern matching does understand non-overlapping slices (slices are special)
let mut v = vec![String::new(), String::new()];
let slice = &mut v[..];
if let [_left, right] = slice {
if let [left, ..] = slice {
left.push_str("left");
}
// Still usable!
right.push_str("right");
}
# }
```
```rust
# fn main() {
// You can split borrows through a `Box` dereference (`Box` is special)
let mut bx = Box::new((0, 1));
let left = &mut bx.0;
let right = &mut bx.1;
*left += 1;
*right += 1;
# }
```
The examples are non-exhaustive 🙂.
### Reborrowing
[As mentioned before,](./st-reborrow.md) reborrows are what make `&mut` reasonable to use.
In fact, they have other special properties you can't emulate with a custom struct and
trait implementations. Consider this example:
```rust
fn foo(s: &mut String) -> &str {
&**s
}
```
Actually, that's too fast. Let's change this a little bit and go step by step.
```rust
fn foo(s: &mut String) -> &str {
let ms: &mut str = &mut **s;
let rs: &str = &*s;
rs
}
```
Here, both `s` and `ms` are going out of scope at the end of `foo`, but this doesn't
invalidate `rs`. That is, reborrowing through references can impose lifetime constraints
on the reborrow, but the reborrow is not dependent on references staying in scope! It is
only dependent on the borrowed data.
This demonstrates that reborrowing is more powerful than nesting references.
### Shared reborrowing
When it comes to detecting conflicts, the borrow checker distinguishes between shared
reborrows and exclusive ones. In particular, creating a shared reborrow will invalidate
any exclusive reborrows of the same value (as they are no longer exclusive). But it will
not invalidated shared reborrows:
```rust
struct Pair {
left: String,
right: String,
}
impl Pair {
fn foo(&mut self) {
// a split borrow: exclusive reborrow, shared reborrow
let left = &mut self.left;
let right = &self.right;
left.push('x');
// Shared reborrow of all of `self`, which "covers" all fields
let this = &*self;
// It invalidates any exclusive reborrows, so this will fail...
// println!("{left}");
// But it does not invalidate shared reborrows!
println!("{right}");
}
}
```
### Two-phase borrows
The following code compiles:
```rust
# fn main() {
let mut v = vec![0];
let shared = &v;
v.push(shared.len());
# }
```
However, if you're aware of the order of evaluation here, it probably seems like it shouldn't.
The implicit `&mut v` should have invalidated `shared` before `shared.len()` was evaluated.
What gives?
This is the result of a feature called two-phase borrows, which is intended to make
[nested method calls](https://rust-lang.github.io/rfcs/2025-nested-method-calls.html)
more ergonomic:
```rust
# fn main() {
let mut v = vec![0];
v.push(v.len());
# }
```
[In the olden days,](https://rust.godbolt.org/z/966j4Eh1f) you would have had to write it like so:
```rust
# fn main() {
let mut v = vec![0];
let len = v.len();
v.push(len);
# }
```
The implementation slipped, which is why the first example compiles too. How far it slipped
is hard to say, as not only is there [no specification,](https://github.com/rust-lang/rust/issues/46901)
the feature doesn't even seem to be documented 🤷.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Citations
Finally we compare what we've covered about `dyn Trait` lifetime elision to the
current reference material, and supply some citations to the elision's storied
history.
## Summary of differences from the reference
The official documentation on trait object lifetime elision
[can be found here.](https://doc.rust-lang.org/reference/lifetime-elision.html#default-trait-object-lifetimes)
In summary, it states that `dyn Trait` lifetimes have a *default object lifetime bound* which varies based on context.
It states that the default bound only takes effect when the lifetime is *entirely* omitted. When you write out `dyn Trait + '_`, the
[normal lifetime elision rules](https://doc.rust-lang.org/reference/lifetime-elision.html#lifetime-elision-in-functions)
apply instead.
In particular, as of this writing, the official documentation states that
> If the trait object is used as a type argument of a generic type then the containing type is first used to try to infer a bound.
> - If there is a unique bound from the containing type then that is the default
> - If there is more than one bound from the containing type then an explicit bound must be specified
>
> If neither of those rules apply, then the bounds on the trait are used:
> - If the trait is defined with a single lifetime bound then that bound is used.
> - If `'static` is used for any lifetime bound then `'static` is used.
> - If the trait has no lifetime bounds, then the lifetime is inferred in expressions and is `'static` outside of expressions.
Some differences from the reference which we have covered are that
- [inferring bounds in expressions applies to `&T` types unless annotated with a named lifetime](./dyn-elision-advanced.md#an-exception-to-inference-in-function-bodies)
- [inferring bounds in expressions applies to ambigous types](./dyn-elision-advanced.md#ambiguous-bounds)
- [when trait bounds apply, they override struct bounds, not the other way around](./dyn-elision-trait-bounds.md#when-they-apply-trait-lifetime-bounds-override-struct-bounds)
- [a `'static` trait bound always applies](./dyn-elision-trait-bounds.md#the-static-case)
- [otherwise, whether trait bounds apply or not depends on complicated contextual rules](./dyn-elision-trait-bounds.md#when-and-how-to-trait-lifetime-bounds-apply)
- they always apply in `impl` headers, associated types, and function bodies
- and technically in `static` contexts, with some odd cavaets
- whether they apply in function signatures depends on the bounding parameters being late or early bound
- a single parameter can apply to a trait bounds with multiple bounds in this context, introducing new implied lifetime bounds
- [trait bounds override `'_` in function bodies](./dyn-elision-trait-bounds.md#function-bodies)
And some other under or undocumented behaviors are that
- [aliases override struct definitions](./dyn-elision-advanced.md#iteraction-with-type-aliases)
- [trait bounds create implied bounds on the trait object lifetime](./dyn-elision-trait-bounds.md#trait-lifetime-bounds-create-an-implied-bound)
- [associated type and GAT bounds do not effect the default trait object lifetime](./dyn-elision-advanced.md#associated-types-and-gats)
## RFCs, Issues, and PRs
Trait objects, and trait object lifetime elision in particular, has undergone a lot of evolution over time.
Here we summarize some of the major developments and issues.
Reminder: a lot of these citations predate the [`dyn Trait` syntax.](https://rust-lang.github.io/rfcs/2113-dyn-trait-syntax.html)
Trait objects used to be just "spelled" as `Trait` in type position, instead of `dyn Trait`.
- [RFC 0192](https://rust-lang.github.io/rfcs/0192-bounds-on-object-and-generic-types.html#lifetime-bounds-on-object-types) first introduced the trait object lifetime
- [including the "intersection lifetime" consideration](https://rust-lang.github.io/rfcs/0192-bounds-on-object-and-generic-types.html#appendix-b-why-object-types-must-have-exactly-one-bound)
- [RFC 0599](https://rust-lang.github.io/rfcs/0599-default-object-bound.html) first introduced *default* trait object lifetimes (`dyn Trait` lifetime elision)
- [RFC 1156](https://rust-lang.github.io/rfcs/1156-adjust-default-object-bounds.html) superceded RFC 0599 (`dyn Trait` lifetime elision)
- [PR 39305](https://github.com/rust-lang/rust/pull/39305) modified RFC 1156 (unofficially) to [allow more inference in function bodies](dyn-elision-advanced.md#an-exception-to-inference-in-function-bodies)
- [RFC 2093](https://rust-lang.github.io/rfcs/2093-infer-outlives.html#trait-object-lifetime-defaults) defined [how `struct` bounds interact with `dyn Trait` lifetime elision](dyn-elision-advanced.md#guiding-behavior-of-your-own-types)
- [Issue 100270](https://github.com/rust-lang/rust/issues/100270) notes that type aliases take precedent in terms of RFC 2093 `dyn Trait` lifetime elision rules
- [Issue 47078](https://github.com/rust-lang/rust/issues/47078) notes that being late-bound influences `dyn Trait` lifetime elision
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Downcasting `Self` parameters
Now let's move on to something a little more complicated. We
[mentioned before](./dyn-safety.md#use-of-self-limitations) that
`Self` is not accepted outside of the receiver, such as when it's
another parameter, as there is no guarantee that the other
parameter has the same base type as the receiver (and if they
are not the same base type, there is no actual implementation to
call).
Let's see how we can work around this to implement
[`PartialOrd`](https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html)
for `dyn Trait`, despite the `&Self` parameter. The trait is a good
fit in the face of type erasure, as we can just return `None` when
the types don't match, indicating that comparison is not possible.
`PartialOrd` requires `PartialEq`, so we'll tackle that as well.
## Downcasting with `dyn Any` to emulate dynamic typing
We haven't had to use `dyn Any` in the previous examples, because
we've been able to maneuver our implementations in such a way that
dynamic dispatch implicitly "downcasted" our erased types to their
concrete base types for us. It's able to do this because the pointer
to the base type is coupled with a vtable that only accepts said base
type, and there is no need for actual dynamic typing or comparing types
at runtime. The conversion is infallible for those cases.
However, now we have two wide pointers which may point to different
base types. In this particular application, we only really need to
know if they have the same base type or not... though it would be
nice to have some *safe* way to recover the erased type of non-receiver
too, instead of whatever casting schenanigans might be necessary.
You might think you could somehow use the vtable pointers to see if
the base types are the same. But unfortunately, [we can't rely on the
vtable to compare their types at runtime.](https://doc.rust-lang.org/std/ptr/fn.eq.html)
> When comparing wide pointers, both the address and the metadata are
tested for equality. However, note that comparing trait object pointers
(`*const dyn Trait`) is unreliable: pointers to values of the same
underlying type can compare inequal (because vtables are duplicated in
multiple codegen units), and pointers to values of different underlying
type can compare equal (since identical vtables can be deduplicated
within a codegen unit).
That's right, false negatives *and* false positives. Fun!
So we need a different mechanism to compare types and know when we
have two wide pointers to the same base type, and that's where `dyn Any`
comes in. [`Any`](https://doc.rust-lang.org/std/any/trait.Any.html) is
the trait to emulate dynamic typing, and
[many fallible downcasting methods](https://doc.rust-lang.org/std/any/trait.Any.html#implementations)
are supplied for the type-erased forms of `dyn Any`, `Box<dyn Any + Send>`,
et cetera. This will allow us to not just compare for base type equality,
but also to safely recover the erased base type ("downcast").
The `Any` trait comes with a `'static` constraint for soundness reasons,
so note that our base types are going to be more limited for this example.
Additionally, the [lack of supertrait upcasting](dyn-trait-coercions.md#supertrait-upcasting)
is going to make things less ergonomic than they will be once that feature is
available.
One last side note, [we look at `dyn Any` in a bit more detail later.](./dyn-any.md)
Well enough meta, let's dive in!
## `PartialEq`
The general idea is that we're going to have a comparison trait, `DynCompare`,
and then implement `PartialEq` for `dyn DynCompare` in a universal manner.
Then our actual trait (`Trait`) can have `DynCompare` as a supertrait, and
implement `PartialEq` for `dyn Trait` by upcasting to `dyn DynCompare`.
In the implementation for `dyn DynCompare`, we're going to have to (attempt to)
downcast to the erased base type. For that to be available we will need to
first be able to upcast from `dyn DynCompare` to `dyn Any`.
As the first step, we're going to use the "supertrait we can blanket implement"
pattern yet again to make a trait that can handle all of our supertrait upcasting needs.
Here it is, [similar to how we've done it before:](dyn-trait-combining.md#manual-supertrait-upcasting)
```rust
use std::any::Any;
trait AsDynCompare: Any {
fn as_any(&self) -> &dyn Any;
fn as_dyn_compare(&self) -> &dyn DynCompare;
}
// Sized types only
impl<T: Any + DynCompare> AsDynCompare for T {
fn as_any(&self) -> &dyn Any {
self
}
fn as_dyn_compare(&self) -> &dyn DynCompare {
self
}
}
trait DynCompare: AsDynCompare {
fn dyn_eq(&self, other: &dyn DynCompare) -> bool;
}
```
There's an `Any: 'static` bound which applies to `dyn Any + '_`, so
[all of those `&dyn Any` are actually `&dyn Any + 'static`.](dyn-elision-trait-bounds.md#the-static-case)
I have also included an `Any` supertrait to `AsDynCompare`, so the
"always `'static`" property holds for `&dyn DynCompare` as well, even
though it isn't strictly necessary. This way, we don't have to worry
about being flexible with the trait object lifetime at all -- it is
just always `'static`.
The downside is that only base types that satisfy the `'static` bound
can be supported, so there may be niche circumstances where you don't
want to include the supertrait bound. However, given that we need to
upcast to `dyn Any`, this must mean you're pretending to be another
type, which seems quite niche indeed. If you do try the non-`'static`
route for your own use case, note that some of the implementations in
this example could be made more general.
Anyway, let's move on to performing cross-type equality checking:
```rust
#use std::any::Any;
#
#trait AsDynCompare: Any {
# fn as_any(&self) -> &dyn Any;
# fn as_dyn_compare(&self) -> &dyn DynCompare;
#}
#
#impl<T: Any + DynCompare> AsDynCompare for T {
# fn as_any(&self) -> &dyn Any {
# self
# }
# fn as_dyn_compare(&self) -> &dyn DynCompare {
# self
# }
#}
#
#trait DynCompare: AsDynCompare {
# fn dyn_eq(&self, other: &dyn DynCompare) -> bool;
#}
impl<T: Any + PartialEq> DynCompare for T {
fn dyn_eq(&self, other: &dyn DynCompare) -> bool {
if let Some(other) = other.as_any().downcast_ref::<Self>() {
self == other
} else {
false
}
}
}
// n.b. this could be implemented in a more general way when
// the trait object lifetime is not constrained to `'static`
impl PartialEq<dyn DynCompare> for dyn DynCompare {
fn eq(&self, other: &dyn DynCompare) -> bool {
self.dyn_eq(other)
}
}
```
Here we've utilized our `dyn Any` upcasting to try and recover a
parameter of our own base type, and if successful, do the actual
(partial) comparison. Otherwise we say they're not equal.
This allows us to implement `PartialEq` for `dyn Compare`.
Then we want to wire this functionality up to our actual trait:
```rust
#use std::any::Any;
#
#trait AsDynCompare: Any {
# fn as_any(&self) -> &dyn Any;
# fn as_dyn_compare(&self) -> &dyn DynCompare;
#}
#
#impl<T: Any + DynCompare> AsDynCompare for T {
# fn as_any(&self) -> &dyn Any {
# self
# }
# fn as_dyn_compare(&self) -> &dyn DynCompare {
# self
# }
#}
#
#trait DynCompare: AsDynCompare {
# fn dyn_eq(&self, other: &dyn DynCompare) -> bool;
#}
#impl<T: Any + PartialEq> DynCompare for T {
# fn dyn_eq(&self, other: &dyn DynCompare) -> bool {
# if let Some(other) = other.as_any().downcast_ref::<Self>() {
# self == other
# } else {
# false
# }
# }
#}
#
#impl PartialEq<dyn DynCompare> for dyn DynCompare {
# fn eq(&self, other: &dyn DynCompare) -> bool {
# self.dyn_eq(other)
# }
#}
trait Trait: DynCompare {}
impl Trait for i32 {}
impl Trait for bool {}
impl PartialEq<dyn Trait> for dyn Trait {
fn eq(&self, other: &dyn Trait) -> bool {
self.as_dyn_compare() == other.as_dyn_compare()
}
}
```
The supertrait bound does most of the work, and we just use
upcasting again -- to `dyn DynCompare` this time -- to be
able to perform `PartialEq` on our `dyn Trait`.
[A blanket implementation in `std`](https://doc.rust-lang.org/std/cmp/trait.PartialEq.html#impl-PartialEq%3CBox%3CT,+A%3E%3E-for-Box%3CT,+A%3E)
gives us `PartialEq` for `Box<dyn Trait>` automatically.
Now let's try it out:
```rust,compile_fail
#use std::any::Any;
#
#trait AsDynCompare: Any {
# fn as_any(&self) -> &dyn Any;
# fn as_dyn_compare(&self) -> &dyn DynCompare;
#}
#
#impl<T: Any + DynCompare> AsDynCompare for T {
# fn as_any(&self) -> &dyn Any {
# self
# }
# fn as_dyn_compare(&self) -> &dyn DynCompare {
# self
# }
#}
#
#trait DynCompare: AsDynCompare {
# fn dyn_eq(&self, other: &dyn DynCompare) -> bool;
#}
#
#impl<T: Any + PartialEq> DynCompare for T {
# fn dyn_eq(&self, other: &dyn DynCompare) -> bool {
# if let Some(other) = other.as_any().downcast_ref::<Self>() {
# self == other
# } else {
# false
# }
# }
#}
#
#impl PartialEq<dyn DynCompare> for dyn DynCompare {
# fn eq(&self, other: &dyn DynCompare) -> bool {
# self.dyn_eq(other)
# }
#}
#
#trait Trait: DynCompare {}
#impl Trait for i32 {}
#impl Trait for bool {}
#
#impl PartialEq<dyn Trait> for dyn Trait {
# fn eq(&self, other: &dyn Trait) -> bool {
# self.as_dyn_compare() == other.as_dyn_compare()
# }
#}
fn main() {
let bx1a: Box<dyn Trait> = Box::new(1);
let bx1b: Box<dyn Trait> = Box::new(1);
let bx2: Box<dyn Trait> = Box::new(2);
let bx3: Box<dyn Trait> = Box::new(true);
println!("{}", bx1a == bx1a);
println!("{}", bx1a == bx1b);
println!("{}", bx1a == bx2);
println!("{}", bx1a == bx3);
}
```
Uh... it didn't work, but for weird reasons. Why is it trying to move out of the
`Box` for a comparison? As it turns out, this is [a longstanding bug in the
language.](https://github.com/rust-lang/rust/issues/31740) Fortunately that issue
also offers a workaround that's ergonomic at the use site: implement `PartialEq<&Self>`
too.
```rust
#use std::any::Any;
#
#trait AsDynCompare: Any {
# fn as_any(&self) -> &dyn Any;
# fn as_dyn_compare(&self) -> &dyn DynCompare;
#}
#
#// Sized types only
#impl<T: Any + DynCompare> AsDynCompare for T {
# fn as_any(&self) -> &dyn Any {
# self
# }
# fn as_dyn_compare(&self) -> &dyn DynCompare {
# self
# }
#}
#
#trait DynCompare: AsDynCompare {
# fn dyn_eq(&self, other: &dyn DynCompare) -> bool;
#}
#
#impl<T: Any + PartialEq> DynCompare for T {
# fn dyn_eq(&self, other: &dyn DynCompare) -> bool {
# if let Some(other) = other.as_any().downcast_ref::<Self>() {
# self == other
# } else {
# false
# }
# }
#}
#
#impl PartialEq<dyn DynCompare> for dyn DynCompare {
# fn eq(&self, other: &dyn DynCompare) -> bool {
# self.dyn_eq(other)
# }
#}
#
#trait Trait: DynCompare {}
#impl Trait for i32 {}
#impl Trait for bool {}
#
#impl PartialEq<dyn Trait> for dyn Trait {
# fn eq(&self, other: &dyn Trait) -> bool {
# self.as_dyn_compare() == other.as_dyn_compare()
# }
#}
#
// New
impl PartialEq<&Self> for Box<dyn Trait> {
fn eq(&self, other: &&Self) -> bool {
<Self as PartialEq>::eq(self, *other)
}
}
fn main() {
let bx1a: Box<dyn Trait> = Box::new(1);
let bx1b: Box<dyn Trait> = Box::new(1);
let bx2: Box<dyn Trait> = Box::new(2);
let bx3: Box<dyn Trait> = Box::new(true);
println!("{}", bx1a == bx1a);
println!("{}", bx1a == bx1b);
println!("{}", bx1a == bx2);
println!("{}", bx1a == bx3);
}
```
Ok, now it works. Phew!
## `PartialOrd`
From here it's mostly mechanical to add `PartialOrd` support:
```diff
+use core::cmp::Ordering;
trait DynCompare: AsDynCompare {
fn dyn_eq(&self, other: &dyn DynCompare) -> bool;
+ fn dyn_partial_cmp(&self, other: &dyn DynCompare) -> Option<Ordering>;
}
-impl<T: Any + PartialEq> DynCompare for T {
+impl<T: Any + PartialOrd> DynCompare for T {
fn dyn_eq(&self, other: &dyn DynCompare) -> bool {
if let Some(other) = other.as_any().downcast_ref::<Self>() {
self == other
} else {
false
}
}
+
+ fn dyn_partial_cmp(&self, other: &dyn DynCompare) -> Option<Ordering> {
+ other
+ .as_any()
+ .downcast_ref::<Self>()
+ .and_then(|other| self.partial_cmp(other))
+ }
}
+impl PartialOrd<dyn DynCompare> for dyn DynCompare {
+ fn partial_cmp(&self, other: &dyn DynCompare) -> Option<Ordering> {
+ self.dyn_partial_cmp(other)
+ }
+}
+impl PartialOrd<dyn Trait> for dyn Trait {
+ fn partial_cmp(&self, other: &dyn Trait) -> Option<Ordering> {
+ self.as_dyn_compare().partial_cmp(other.as_dyn_compare())
+ }
+}
+impl PartialOrd<&Self> for Box<dyn Trait> {
+ fn partial_cmp(&self, other: &&Self) -> Option<Ordering> {
+ <Self as PartialOrd>::partial_cmp(self, *other)
+ }
+}
```
[Here's the final playground.](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=8142d76abd2b2a4ef75950029e035371)
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Scrutinize compiler advice
The compiler gives better errors than pretty much any other language I've used, but it still does give some poor suggestions in some cases.
It's hard to turn a borrow check error into an accurate "what did the programmer mean" suggestion.
So suggested bounds are an area where it can be better to take a moment to try and understand what's going on with the lifetimes,
instead of just blindly applying compiler advice.
I'll cover a few scenarios here.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Avoid self-referential structs
By self-referential, I mean you have one field that is a reference, and that reference points to another field (or contents of a field) in the same struct.
```rust
struct Snek<'a> {
owned: String,
// Like if you want this to point to the `owned` field
borrowed: &'a str,
}
```
The only safe way to construct this to be self-referential is to take a `&'a mut Snek<'a>`, get a `&'a str` to the `owned` field, and assign it to the `borrowed` field.
```rust
#struct Snek<'a> {
# owned: String,
# // Like if you want this to point to the `owned` field
# borrowed: &'a str,
#}
impl<'a> Snek<'a> {
fn bite(&'a mut self) {
self.borrowed = &self.owned;
}
}
```
[And as was covered before,](pf-borrow-forever.md) that's an anti-pattern because you cannot use the self-referencial struct directly ever again.
The only way to use it at all is via a (reborrowed) return value from the method call that required `&'a mut self`.
So it's technically possible, but so restrictive it's pretty much always useless.
Trying to create self-referential structs is a common newcomer misstep, and you may see the response to questions about them in the approximated form of "you can't do that in safe Rust".
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Clonable `Box<dyn Trait>`
What can you do if you want a `Box<dyn Trait>` that you can clone?
You can't have `Clone` as a [supertrait,](dyn-trait-combining.md)
because `Clone` requires `Sized` and that will make `Trait` be
[non-object-safe.](dyn-safety.md)
You might be tempted to do this:
```rust
trait Trait {
fn dyn_clone(&self) -> Self where Self: Sized;
}
```
But then `dyn Trait` won't have the method available, and that will
[be a barrier to implementing `Trait` for `Box<dyn Trait>`.](dyn-trait-box-impl.md)
But hey, you know what? Since this only really makes sense for
base types that implement `Clone`, we don't need a method that returns
`Self`. The base types already have that, it's called `clone`.
What we ultimately want is to get a `Box<dyn Trait>` instead, like so:
```rust
trait Trait {
fn dyn_clone<'s>(&self) -> Box<dyn Trait + 's> where Self: 's;
}
// example implementor
impl Trait for String {
fn dyn_clone<'s>(&self) -> Box<dyn Trait + 's> where Self: 's {
Box::new(self.clone())
}
}
```
If we omit all the lifetime stuff, it only works with `Self: 'static`
due to the [default `'static` lifetime.](dyn-elision-basic.md) And
sometimes, that's perfectly ok! But we'll stick with the more general
version for this example.
The example implementation will make `dyn Trait` do the right thing
(clone the underlying base type via its implementation). We can't have
a default body though, because the implementation requires `Clone`
and `Sized`, which again, we don't want as bounds.
But this is exactly the situation we had when we looked at
[manual supertrait upcasting](./dyn-trait-combining.md#manual-supertrait-upcasting)
and the [`self` receiver helper](./dyn-trait-box-impl.md)
in previous examples. The same pattern
will work here: move the method to a helper supertrait and supply
a blanket implementation for those cases where it makes sense.
```rust
trait DynClone {
fn dyn_clone<'s>(&self) -> Box<dyn Trait + 's> where Self: 's;
}
impl<T: Clone + Trait> DynClone for T {
fn dyn_clone<'s>(&self) -> Box<dyn Trait + 's> where Self: 's {
Box::new(self.clone())
}
}
trait Trait: DynClone {}
```
Now we're ready for `Box<dyn Trait + '_>`.
```rust
#trait Trait: DynClone {}
#trait DynClone {
# fn dyn_clone<'s>(&self) -> Box<dyn Trait + 's> where Self: 's;
#}
#impl<T: Clone + Trait> DynClone for T {
# fn dyn_clone<'s>(&self) -> Box<dyn Trait + 's> where Self: 's {
# Box::new(self.clone())
# }
#}
impl Trait for Box<dyn Trait + '_> {}
impl Clone for Box<dyn Trait + '_> {
fn clone(&self) -> Self {
// Important! "recursive trait implementation" style
(**self).dyn_clone()
}
}
```
It's important that we called `<dyn Trait as DynClone>::dyn_clone`! Our
blanket implementation of `DynClone` was bounded on `Clone + Trait`, but
now we have implemented both of those for `Box<dyn Trait + '_>`. If we
had just called `self.dyn_clone()`, the call graph would go like so:
```rust,ignore
<Box<dyn Trait> as Clone >::clone()
<Box<dyn Trait> as DynClone>::dyn_clone()
<Box<dyn Trait> as Clone >::clone()
<Box<dyn Trait> as DynClone>::dyn_clone()
<Box<dyn Trait> as Clone >::clone()
<Box<dyn Trait> as DynClone>::dyn_clone()
...
```
Yep, infinite recursion. Just like when implementing `Trait for Box<dyn Trait>`,
we need to call the `dyn Trait` method directly to avoid this.
---
There is also a crate for this use case: [the `dyn-clone` crate.](https://crates.io/crates/dyn_clone)
A comparison with the crate is beyond the scope of this guide for now.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Practical suggestions for building intuition around borrow errors
Ownership, borrowing, and lifetimes covers a lot of ground in Rust, and thus this section is somewhat long.
It is also hard to create a succinct overview of the topic, as what aspects of the topic a newcomer
first encounters depends on what projects they take on in the process of learning Rust. The genesis of
this guide was advice for someone who picked a zero-copy regular expression crate as their learning project,
and as such they ran into a lot of lifetime issues off the bat. Someone who chose a web framework would be
more likely to run into issues around `Arc` and `Mutex`, those who start with `async` projects will likely
run into many `async`-specific errors, and so on.
Despite the length of this section, there are entire areas it doesn't yet touch on, such as destructor
mechanics, shared ownership and shared mutability, and so on.
Even so, it's not expected that anyone will absorb everything in this guide all at once. Instead,
it's intended to be a broad introduction to the topic. Skim it on your first pass and take time on
the parts that seem relevant, or use them as pointers to look up more in-depth documentation on your
own. Hopefully you will get a feel for what kind errors can arise even if you haven't ran into them
yourself yet, so that you're not completely baffled when they do arise.
In general, your mental model of ownership and borrowing will go through a few stages of evolution.
It will pay off to return to any given area of the topic with fresh eyes every once in awhile.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Sectional introduction
Rust's type-erasing `dyn Trait` offers a way to treat different implementors
of a trait in a homogenous fashion while remaining strictly and statically
(i.e. compile-time) typed. For example: if you want a `Vec` of values which
implement your trait, but they might not all be the same base type, you need
type erasure so that you can create a `Vec<Box<dyn Trait>>` or similar.
`dyn Trait` is also useful in some situations where generics are undesirable,
or to type erase unnameable types such as closures into something you need to
name (such as a field type, an associated type, or a trait method return type).
There is a lot to know about when and how `dyn Trait` works or does not, and
how this ties together with generics, lifetimes, and Rust's type system more
generally. It is therefore not uncommon to get somewhat confused about
`dyn Trait` when learning Rust.
In this section we take a look at what `dyn Trait` is and is not, the limitations
around using it, how it relates to generics and opaque types, and more.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Advice to add bound which implies lifetime equality
The example for this one is very contrived, but [consider the output here:](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=aad18e17e4308fc4e94c5fd039e64d90)
```rust
fn f<'a, 'b>(s: &'a mut &'b mut str) -> &'b str {
*s
}
```
```rust
= help: consider adding the following bound: `'a: 'b`
```
With the nested lifetime in the argument, there's already an implied `'b: 'a` bound.
If you follow the advice and add a `'a: 'b` bound, then the two bounds together imply that `'a` and `'b` are in fact the same lifetime.
More clear advice would be to use a single lifetime. Even better advice for this particular example would be to return `&'a str` instead.
Another possible pitfall of blindly following this advice is ending up with something like this:
```rust
impl Node<'a> {
fn g<'s: 'a>(&'s mut self) { /* ... */ }
```
That's [the `&'a mut Node<'a>` anti-pattern](pf-self.md) in disguise! This will probably be unusable and hints at a deeper problem that needs solved.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# `dyn` safety (object safety)
There exists traits for which you cannot create a `dyn Trait`:
```rust,compile_fail
let s = String::new();
let d: &dyn Clone = &s;
```
Instead of repeating all the rules here,
[I'll just link to the reference.](https://doc.rust-lang.org/reference/items/traits.html#object-safety)
You should go read that first.
What may not be immediately apparent is *why* these limitations exists.
The rest of this page explores some of the reasons.
## The `Sized` constraints
Before we get into the restrictions, let's have an aside about how the
`Sized` constraints work with `dyn Trait` and `dyn` safety.
Rust uses `Sized` to indicate that
- A trait is not `dyn` safe
- A method is not `dyn`-dispatchable
- An associated function is not callable for `dyn Trait`
- Even though it never can be (so far), you have to declare this for the sake of being explicit and for potential forwards compatibility
This makes some sense, as `dyn Trait` is not `Sized`. So a `dyn Trait`
cannot implement a trait with `Sized` as a supertrait, and a `dyn Trait`
can't call methods (or associated functions) that require `Sized` either.
However, it's still a hack as there are types which are not `Sized` but also
not `dyn Trait`, and we might want to implement our trait for those, *including*
some methods which are not `dyn`-dispatchable (such as generic methods).
Currently that's just not possible in Rust (the non-`dyn`-dispatchable methods
will also not be available for other unsized types).
The next few paragraphs demonstrate (or perhaps rant about) how this can be an annoying limitation.
If you'd rather get on with learning practical Rust, [you may want to skip ahead 🙂.](#receiver-limitations)
Consider this example, where we've added a `Sized` bound in order to remain a `dyn`-safe trait:
```rust
# trait Bound<T: ?Sized> {}
trait Trait {
// Opt-out of `dyn`-dispatchability for this method because it's generic
fn method<T: Bound<Self>>(&self) where Self: Sized;
}
```
If you try to implement this trait for `str`, you won't have `method`
available, even if it would logically make sense to have it available.
Moreover, if you write the implementation like so:
```rust,compile_fail
# trait Bound<T: ?Sized> {}
# trait Trait {
# fn method<T: Bound<Self>>(&self) where Self: Sized;
# }
impl Trait for str {
// `Self: Sized` isn't true, so don't bother with `method`
}
```
You get an error saying you must provide `method`, even though the
bounds cannot be satisfied. So then you can provide a perfectly
functional implementation:
```rust,compile_fail
# trait Bound<T: ?Sized> {}
# trait Trait {
# fn method<T: Bound<Self>>(&self) where Self: Sized;
# }
impl Trait for str {
fn method<T: Bound<Self>>(&self) where Self: Sized {
// do logical `method` things
}
}
```
Whoops, it doesn't accept that either! 😠 We have to implement it
without the bound, like so:
```rust
# trait Bound<T: ?Sized> {}
# trait Trait {
# fn method<T: Bound<Self>>(&self) where Self: Sized;
# }
impl Trait for str {
fn method<T: Bound<Self>>(&self) {
// do logical `method` things
}
}
```
And that compiles... but we can never actually call it.
```rust,compile_fail
# trait Bound<T: ?Sized> {}
# trait Trait {
# fn method<T: Bound<Self>>(&self) where Self: Sized;
# }
# impl Trait for str {
# fn method<T: Bound<Self>>(&self) {
# }
# }
fn main() {
"".method();
}
```
Alternatively, we can exploit the fact that higher-ranked bounds
are checked at the call site and not the definition site to sneak
in the unsatisfiable `Self: Sized` bound in a way that compiles:
```rust
# trait Bound<T: ?Sized> {}
# trait Trait {
# fn method<T: Bound<Self>>(&self) where Self: Sized;
# }
impl Trait for str {
// Still not callable, but compiles: vvvvvvv due to this binder
fn method<T: Bound<Self>>(&self) where for<'a> Self: Sized {
unreachable!()
}
}
```
But naturally the method still cannot be called, as the bound is not satisfiable.
This is a pretty sad state of affairs. Ideally, there would be a
distinct trait for opting out of `dyn` safety and dispatchability
instead of using `Sized` for this purpose; let's call it `NotDyn`.
Then we could have `Sized: NotDyn` for backwards compatibility,
change the bound above to be `NotDyn`, and have our implementation
for `str` be functional.
There also some other future possibilities that may improve the situation:
- [Some resolution of RFC issue 2829](https://github.com/rust-lang/rfcs/issues/2829)
or the duplicates linked within would allow omitting the method altogether
(but it would still not be callable)
- [RFC 2056](https://rust-lang.github.io/rfcs/2056-allow-trivial-where-clause-constraints.html)
will allow defining the method with the trivially unsatifiable bound without
exploiting the higher-ranked trick (but it will still not be callable)
- [RFC 3245](https://rust-lang.github.io/rfcs/3245-refined-impls.html) will allow
calling `<str as Trait>::method` and refined implementations more generally
But I feel removing the conflation between `dyn` safety and `Sized` would
be more clear and correct regardless of any future workarounds that may exist.
## Receiver limitations
The requirement for some sort of `Self`-based receiver on `dyn`-dispatchable
methods is to ensure the vtable is available. Some wide pointer to `Self`
needs to be present in order to
[find the vtable and perform dynamic dispatch.](dyn-trait-impls.md#how-dyn-trait-implements-trait)
Arguably this could be expanded to methods that take a single,
non-receiver `&Self` and so on.
As for the other limitation on receiver types, [the compiler has to know
how to go backwards from type erased version to original
version](./dyn-trait-impls.md#other-receivers) in order to
implement `Trait`. This may be generalized some day, but for
now it's a restricted set.
## Generic method limitations
In order to support type-generic methods, there would need to be
a function pointer in the vtable for every possible type that the
generic could take on. Not only would this create vtables of
unweildly size, it would also require some sort of global analysis.
After all, every crate which uses your trait might define new types
that meet the trait bounds in question, and they (or you) might also
want to call the method using those types.
You can sometimes work around this limitation by type erasing the
generic type parameter in question (in the main method, as an
alternative method, or in a different "erased" trait).
[We'll see an example of this later.](./dyn-trait-erased.md)
## Use of `Self` limitations
Methods which take some form of `Self` other than as a receiver
can depend on the parameter being exactly the same as the
implementing type. But this can't be relied upon once the base
types have been erased.
For example, consider [`PartialEq<Self>`:](https://doc.rust-lang.org/std/cmp/trait.PartialEq.html)
```rust
// Simplified
pub trait PartialEq {
fn partial_eq(&self, rhs: &Self);
}
```
If this were implemented for `dyn PartialEq`, the `rhs` parameter
would be a `&dyn PartialEq` like `self` is. But there is no
guarantee that the base types are the same! Both `u8` and `String`
implement `PartialEq` for example, but there's no facility to
compare them for equality (and Rust has no interest in handling
this in an arbitrary way).
You can sometimes work around this by supplying your own implementations
for some *other* `dyn Trait`, perhaps utilizing the `Any` trait
to emulate dynamic typing and reflection.
[We give an example of this approach later.](./dyn-trait-eq.md)
[The `impl Clone for Box<dyn Trait>` example](./dyn-trait-clone.md)
demonstrates handling a case where `Self` is the return value.
## GAT limitations
GATs are too new to support type erasing as-of-yet. We'll need
some way to embed the GAT into the `dyn Trait` as a parameter,
[similar to how is done for non-generic associated types.](./dyn-trait-coercions.md#associated-types)
## Associated constant limitations
Similarly, supporting associated constants will require at least
[support for associated constant equality.](https://github.com/rust-lang/rust/issues/92827)
## History
[Object safety was introduced in RFC 0255,](https://rust-lang.github.io/rfcs/0255-object-safety.html)
and [RFC 0546](https://rust-lang.github.io/rfcs/0546-Self-not-sized-by-default.html) removed the
implied `Sized` bound on traits and added the rule that traits with (explicit) `Sized` bounds
are not object safe.
Both RFCs were implemented before Rust 1.0.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Advanced guidelines
In this section, we cover how to guide elision behavior for your own
generic data types, and point out some exceptions to the basic guidelines
presented in the previous section.
## Guiding behavior of your own types
When you declare a custom type with a lifetime parameter `'a` and a trait parameter `T: ?Sized`,
including an *explicit* `T: 'a` bound will result in elision behaving the same as
it does for references `&'a T` and for `std` types like `Ref<'a, T>`:
```rust
// When `T` is replaced by `dyn Trait` with an elided lifetime, the elided lifetime
// will default to `'a` outside of function bodies
struct ExplicitOutlives<'a, T: 'a + ?Sized>(&'a T);
```
If your type has no lifetime parameter, or if there is no bound between the type
parameter and the lifetime parameter, the default for elided `dyn Trait` lifetimes
will be `'static`, like it is for `Box<T>`. *This is true even if there is an
**implied** `T: 'a` bound.* For example:
```rust,compile_fail
trait Trait {}
impl Trait for () {}
// There's an *implied* `T: 'a` bound due to the `&'a T` field (RFC 2093)
struct InferredOutlivesOnly<'a, T: ?Sized>(&'a T);
// Yet this function expects an `InferredOutlivesOnly<'a, dyn Trait + 'static>`
fn example<'a>(ioo: InferredOutlivesOnly<'a, dyn Trait>) {}
// Thus this fails to compile
fn attempt<'a>(ioo: InferredOutlivesOnly<'a, dyn Trait + 'a>) {
example(ioo);
}
```
If you make `T: 'a` explicit in the definition of the `struct`, the
example will compile.
If `T: 'a` is an inferred bound of your type, and `T: ?Sized`, I recommend
including the explicit `T: 'a` bound.
## Ambiguous bounds
If you have more than one lifetime bound in your type definition, the
bound is considered ambiguous, even if one of the lifetimes is `'static`
(or more generally, even if one lifetime is known to outlive the other).
Such structs are rare, but if you have one, you usually must be explicit
about the `dyn Trait` lifetime:
```rust,compile_fail
# trait Trait {}
# impl Trait for () {}
struct S<'a, 'b: 'a, T: 'a + 'b + ?Sized>(&'a &'b T);
// error[E0228]: the lifetime bound for this object type cannot be deduced
// from context; please supply an explicit bound
const C: S<dyn Trait> = S(&&());
```
However, in function bodies, the lifetime is still inferred; moreover it
is inferred independent of any annotation of the lifetime types:
```rust
# trait Trait {}
# impl Trait for () {}
struct Weird<'a, 'b, T: 'a + 'b + ?Sized>(&'a T, &'b T);
fn example<'a, 'b>() {
// Either of `dyn Trait + 'a` or `dyn Trait + 'b` is an error,
// so the `dyn Trait` lifetime must be inferred independently
// from `'a` and `'b`
let _: Weird<'a, 'b, dyn Trait> = Weird(&(), &());
}
```
(This is contrary to the documentation in the reference, and
[ironically more flexible than non-ambiguous types.](#an-exception-to-inference-in-function-bodies)
In this particular example, the lifetime will be inferred
[analogously to the lifetime intersection mentioned previously.](dyn-trait-lifetime.md#when-multiple-lifetimes-are-involved))
## Iteraction with type aliases
When you use a type alias, the bounds between lifetime parameters and type
parameters *on the `type` alias* determine how `dyn Trait` lifetime elision
behaves, overriding the bounds on the aliased type (be they stronger or weaker).
```rust,compile_fail
# trait Trait {}
// Without the `T: 'a` bound, the default trait object lifetime
// for this alias is `'static`
type MyRef<'a, T> = &'a T;
// So this compiles
fn foo(mr: MyRef<'_, dyn Trait>) -> &(dyn Trait + 'static) {
mr
}
// With the `T: 'a` bound, the default trait object lifetime for
// this alias is the lifetime parameter
type MyOtherRef<'a, T: 'a> = MyRef<'a, T>;
// So this does not compile
fn bar(mr: MyOtherRef<'_, dyn Trait>) -> &(dyn Trait + 'static) {
mr
}
```
[See issue 100270.](https://github.com/rust-lang/rust/issues/100270)
This is undocumented.
## Associated types and GATs
`dyn Trait` lifetime elision applies in this context. There are some
things of note, however:
* Bounds on associated types and GATs don't seem to have any effect
* Eliding non-`dyn Trait` lifetimes is not allowed
For example:
```rust
# trait Trait {}
trait Assoc {
type T;
}
impl Assoc for () {
// Box<dyn Trait + 'static>
type T = Box<dyn Trait>;
}
impl<'a> Assoc for &'a str {
// &'a (dyn Trait + 'a)
type T = &'a dyn Trait;
// This is a compilation error as the reference lifetime is elided
// type T = &dyn Trait;
}
```
```rust,compile_fail
# trait Trait {}
# impl Trait for () {}
trait BoundedAssoc<'x> {
type BA: 'x + ?Sized;
}
// Still `Box<dyn Trait + 'static>`
impl<'x> BoundedAssoc<'x> for () { type BA = Box<dyn Trait>; }
// Fails
fn bib<'a>(obj: Box<dyn Trait + 'a>) {
let obj: <() as BoundedAssoc<'a>>::BA = obj;
}
```
## An exception to inference in function bodies
There is also an exception to the elided `dyn Trait` lifetime being inferred
in function bodies. If you have a reference-like type, and you annotate the
lifetime of the non-`dyn Trait` lifetime with a named lifetime, then the
elided `dyn Trait` lifetime will be the same as the annotated lifetime
(similar to how things behave outside of a function body):
```rust,compile_fail
trait Trait {}
impl Trait for () {}
fn example<'a>(arg: &'a ()) {
let dt: &'a dyn Trait = arg;
// fails
let _: &(dyn Trait + 'static) = dt;
}
```
According to the reference, `&dyn Trait` should always behave like this.
However, if the outer lifetime is elided or if `'_` is used for the outer lifetime,
*the `dyn Trait` lifetime is inferred **independently** of the reference lifetime:*
```rust
# trait Trait {}
# impl Trait for () {}
fn example() {
let local = ();
// The outer reference lifetime cannot be `'static`...
let obj: &dyn Trait = &local;
// Yet the `dyn Trait` lifetime is!
let _: &(dyn Trait + 'static) = obj;
}
```
This is not documented anywhere and is in conflict with the reference.
[It was implemented here,](https://github.com/rust-lang/rust/pull/39305)
with no team input or FCP. 🤷
However, the chances that you will run into a problem due to this behavior
is low, as it's rare to annotate lifetimes within a function body.
## What we are not yet covering
To the best of our knowledge, this covers the behavior of `dyn Trait` lifetime elision
*when there are no lifetime bounds on the trait itself.* Non-`'static` lifetime bounds
on the trait itself lead to some more nuanced behavior; we'll cover some of them in the
[next section.](./dyn-elision-trait-bounds.md)
## Advanced guidelines summary
So all in all, we have three common categories of `dyn Trait` lifetime elision
when ignoring lifetime bounds on traits:
- `'static` for type parameters with no (explicit) lifetime bound
- E.g. `Box<dyn Trait>` (`Box<dyn Trait + 'static>`)
- E.g. `struct Unbounded<'a, T: ?Sized>(&'a T)`
- Another lifetime parameter for type parameters with a single (explicit) lifetime bound
- E.g. `&'a dyn Trait` (`&'a dyn Trait + 'a`)
- E.g. `Ref<'a, dyn Trait>` (`Ref<'a, dyn Trait + 'a>`)
- E.g. `struct Bounded<'a, T: 'a + ?Sized>(&'a T)`
- Ambiguous due to multiple bounds (rare)
- E.g. `struct Weird<'a, T: 'a + 'static>(&'a T);`
And the behavior in various contexts is:
| | `static` | `impl` | \[G\]AT | `fn` in | `fn` out | `fn` body |
| - | - | - | - | - | - | - |
| `Box<dyn Trait>` | `'static` | `'static` | `'static` | `'static` | `'static` | Inferred
| `&dyn Trait` | Ref | Ref | E0637 | Ref | Ref | Inferred
| `&'a dyn Trait` | Ref | Ref | Ref | Ref | Ref | Ref
| Ambig. | E0228 | E0228 | E0228 | E0228 | E0228 | Inferred
With the following notes:
- `type` alias bounds take precedence over the aliased type bounds
- Associated type and GAT bounds do not effect the default
For contrast, the "normal" elision rules work like so:
| | `static` | `impl` | \[G\]AT | `fn` in | `fn` out | `fn` body |
| - | - | - | - | - | - | - |
| `Box<dyn Tr + '_>` | `'static` | Fresh | E0637 | Fresh | Elision | Inferred
| `&(dyn Trait + '_`) | `'static` | Fresh | E0637 | Fresh | Elision | Inferred
| `&'a (dyn Trait + '_`) | `'static` | Fresh | E0637 | Fresh | Elision | Inferred
| Ambig. with `'_` | `'static` | Fresh | E0637 | Fresh | Elision | Inferred
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# &mut inputs don't "downgrade" to &
Still talking about this signature:
```rust
fn quz(&mut self) -> &str { todo!() }
```
Newcomers often expect `self` to only be shared-borrowed after `quz` returns, because the return is a shared reference.
But that's not how things work; `self` remains *exclusively* borrowed for as long as the returned `&str` is valid.
I find looking at the exact return type a trap when trying to build a mental model for this pattern.
The fact that the lifetimes are connected is crucial, but beyond that, instead focus on the input parameter:
You *cannot call* the method *until you have created* a `&mut self` with a lifetime as long as the return type has.
Once that exclusive borrow (or reborrow) is created, the exclusiveness lasts for the entirety of the lifetime.
Moreover, you give the `&mut self` away by calling the method (it is not `Copy`), so you can't create any other
reborrows to `self` other than through whatever the method returns to you (in this case, the `&str`).
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# More about `dyn Any`
We've taken a lot of care to emphasize that `dyn Trait` isn't
a supertype nor a form of dynamic typing, but
[in one of the examples](dyn-trait-eq.md#downcasting-with-dyn-any-to-emulate-dynamic-typing)
we saw that `dyn Any` *can* "downcast" back to the erased
base type. Or [to quote the official documentation,](https://doc.rust-lang.org/std/any/trait.Any.html)
`Any` is
> A trait to emulate dynamic typing.
Here we take a closer look at `dyn Any` specifically.
## The general idea
The `Any` trait is implemented for all types which satisfy a `'static` bound.
It supplies a method `type_id`, which returns
[an opaque but unique identifier](https://doc.rust-lang.org/std/any/struct.TypeId.html)
of the implementing type. We also have
[`TypeId::of::<T>`,](https://doc.rust-lang.org/std/any/struct.TypeId.html#method.of)
which lets us look up the `TypeId` of any `'static` type.
Together, this allows fallible downcasting by doing [things along these lines:](https://doc.rust-lang.org/src/core/any.rs.html)
```rust
pub fn downcast_ref<T: Any>(&self) -> Option<&T> {
if self.is::<T>() {
// SAFETY: just checked whether we are pointing to the correct type, and we can rely on
// that check for memory safety because we have implemented Any for all types; no other
// impls can exist as they would conflict with our impl.
unsafe { Some(self.downcast_ref_unchecked()) }
} else {
None
}
}
```
And [`is`](https://doc.rust-lang.org/std/any/trait.Any.html#method.is) simply compares
`TypeId::of::<T>()` to `self.type_id()`.
Details of specific downcasts aside, that's pretty much it! All that was
needed is the global identifier (`TypeId`). The standard library provides
the various downcasting methods in order to encapsulate the required
`unsafe`ty.
[As a reminder from before,](dyn-trait-eq.md#downcasting-with-dyn-any-to-emulate-dynamic-typing)
the vtable pointers themselves are not suitable to use as a global identifier
of erased types. The same trait can have multiple vtables due to codegen
units and linker implementations, and different traits can have the same
vtable due to deduplication optimizations.
[Where exactly the language goes with respect to comparing vtable pointers
is an open question.](https://github.com/rust-lang/rust/issues/106447) It's
not unimaginable that all vtables will gain some lifetime-erased version of
`TypeId`, but [related to some discussion below,](#why-static) this may not
be as straightforward as it may sound.
## Downcasting methods are not trait methods
Note that the *only* method available in the `Any` trait is `type_id`.
[All of the downcasting methods](https://doc.rust-lang.org/std/any/trait.Any.html#implementations)
are implemented on the erased `dyn Any` directly, or on `Box<dyn Any>`, or
on `dyn Any + Send`, etc. Downcasting doesn't generally make sense for a
non-erased base type -- you already know what it is!
Another good reason for this is that
[types like `Box<dyn Any>` implement `Any`,](https://doc.rust-lang.org/std/any/index.html#smart-pointers-and-dyn-any)
making easy to accidentally call the `Box<dyn Any>` implementation instead of
the `dyn Any` implementation in the case of `type_id`. It would be much more
fraught if `downcast_ref` worked like this, for example.
However, this does mean that having `Any` as a supertrait does not allow
downcasting for your own `dyn Trait`s. [Instead you have to first upcast
to dyn Any,](./dyn-trait-combining.md#manual-supertrait-upcasting) and then
downcast. Once we have [built-in supertrait upcasting,](dyn-trait-coercions.md#supertrait-upcasting)
the process will involve much less boilerplate when an `Any` suptertrait
bound is acceptable.
## Some brief examples
[In our other example,](dyn-trait-eq.md#downcasting-with-dyn-any-to-emulate-dynamic-typing)
we used [manual supertrait casting](./dyn-trait-combining.md#manual-supertrait-upcasting) to
turn a `dyn DynCompare` into a `dyn Any`. This was a case where we really just wished we
could attempt to downcast `dyn DynCompare` itself.
Here we instead look at some simple examples of type erasing and downcasting concrete
types directly.
### The basics
Getting a `dyn Any` isn't any different than any other kind of type erasure:
```rust
# use std::any::Any;
let mut i = 0;
let rf: &dyn Any = &();
let mt: &mut dyn Any = &mut i;
let bx: Box<dyn Any> = Box::new(String::new());
```
You have to keep in mind the `'static` requirement though:
```rust,compile_fail
# use std::any::Any;
let local = ();
let borrow = &local;
// fails because `borrow` is not `'static`
let _: &dyn Any = &borrow;
```
On the upside, [`dyn Any` is *always* `dyn Any + 'static`,](dyn-elision-trait-bounds.md#the-static-case)
which makes many trait object related borrow check errors impossible.
Although `Any` is implemented for unsized types, and unsized types can
have `TypeId`s too, the `Sized` restriction for type erasure still applies:
```rust,compile_fail
# use std::any::Any;
// fails because `str` is not `Sized`
let _: &dyn Any = "";
```
Fallible downcasting is pretty straightforward as well. For references
the return is an `Option`:
```rust
# use std::any::Any;
# let mut i = 0;
# let rf: &dyn Any = &();
# let mt: &mut dyn Any = &mut i;
assert_eq!( rf.downcast_ref::<()>(), Some(&()) );
assert_eq!( rf.downcast_ref::<String>(), None );
assert!( mt.downcast_mut::<i32>().is_some() );
assert_eq!( mt.downcast_mut::<String>(), None );
```
For `Box`es, the return type is a `Result` so that the you can keep
ownership of the `Box<dyn Any>` if the downcast is not applicable.
The `Ok` variant is a `Box<T>` so that you can choose whether it's
appropriate to unbox the type or not.
```rust
# use std::any::Any;
# let bx: Box<dyn Any> = Box::new(String::new());
if let Err(bx) = bx.downcast::<i32>() {
println!("Hmm, not an `i32`.");
if let Ok(bx) = bx.downcast::<String>() {
let s: String = *bx;
println!("Yep, it was a `String`.");
}
}
```
That's it for the basics!
### The `TypeMap` pattern
For an example with a more practical bent, let's say you wanted to store a distinct
value for each distinct type you may encounter, for some reason. Maybe you're
storing callbacks for types which are likewise type erased, say, and the callback
for a `Dog` would be different than that for a `Cat`, and you might not even have
a callback for the `Mouse`.
One way to do this would be to have a data structure that maps a `TypeId` to the
values. A "type map", if you will:
```rust
# use std::any::Any;
# use std::any::TypeId;
# use std::collections::HashMap;
pub struct TypeMap<V> {
map: HashMap<TypeId, V>,
}
impl<V> TypeMap<V> {
pub fn insert<T: Any>(&mut self, value: V) -> Option<V> {
let id = TypeId::of::<T>();
self.map.insert(id, value)
}
pub fn get_mut<T: Any>(&mut self) -> Option<&mut V> {
self.get_mut_of(&TypeId::of::<T>())
}
pub fn get_mut_of(&mut self, id: &TypeId) -> Option<&mut V> {
self.map.get_mut(id)
}
// ...
}
```
This could be used for the callback idea:
```rust
# use std::any::Any;
# use std::any::TypeId;
# use std::collections::HashMap;
# pub struct TypeMap<V> {
# map: HashMap<TypeId, V>,
# }
# impl<V> TypeMap<V> {
# pub fn insert<T: Any>(&mut self, value: V) -> Option<V> {
# let id = TypeId::of::<T>();
# self.map.insert(id, value)
# }
# pub fn get_mut<T: Any>(&mut self) -> Option<&mut V> {
# self.get_mut_of(&TypeId::of::<T>())
# }
# pub fn get_mut_of(&mut self, id: &TypeId) -> Option<&mut V> {
# self.map.get_mut(id)
# }
# }
pub struct Visitor {
map: TypeMap<Box<dyn FnMut(&dyn Any)>>,
}
impl Visitor {
// Because we return closures we have previously created,
// we should take care to not *assume* that the parameter
// in the callback is of the correct type. If we never
// let our closures escape to the outside world, we could
// safely assume that the parameter was, in fact, `T`.
//
// It would be sound to `panic` if the parameter was not
// `T` even if we let the closures escape, but it would
// not be sound to use the unstable `downcast_ref_unchecked`
// so long as we're letting the closure escape.
pub fn register<T, F>(&mut self, mut callback: F) -> Option<Box<dyn FnMut(&dyn Any)>>
where
T: Any,
F: 'static + FnMut(&T),
{
let callback = Box::new(move |any: &dyn Any| {
if let Some(t) = any.downcast_ref::<T>() {
callback(t);
}
});
self.map.insert::<T>(callback)
}
pub fn get_callback<T: Any>(&mut self) -> Option<impl FnMut(&T) + '_> {
self.map
.get_mut::<T>()
.map(|f| {
|t: &T| f(t)
})
}
pub fn visit<T: Any>(&mut self, value: &T) -> bool {
if let Some(mut callback) = self.get_callback::<T>() {
callback(value);
true
} else {
false
}
}
pub fn visit_erased(&mut self, value: &dyn Any) -> bool {
if let Some(callback) = self.map.get_mut_of(&value.type_id()) {
callback(value);
true
} else {
false
}
}
}
```
Above we have also type erased our callback signatures, since we needed
a single type for our values. This is somewhat the data structure version
of [erasing a trait.](./dyn-trait-erased.md)
For whatever reason you might want to map by types, this is
[an existing pattern in the ecosystem.](https://lib.rs/keywords/typemap)
## Why `'static`?
The `Any` trait is implemented for all types which satisfy a `'static` bound,
but no other types; in fact, it has a `'static` bound and thus *cannot* be implemented
for types that do not meet a `'static` bound. This means that emulating dynamic
typing with `Any` cannot be done for borrowing types (except those that borrow for
`'static`), for example.
Why such a harsh restriction? In short, lifetimes are erased before runtime, types
with different lifetimes would have to have the same `TypeId` identifier, and thus
downcasting based on the `TypeId` would ignore lifetimes and be *wildly unsound*.
Lifetimes are a part of types and certain relationships must be preserved for
soundness, but as the lifetimes have been erased before runtime, it's not possible
to preserve the relationships dynamically.
Thus there is just no sound way to use `TypeId` or any similar lifetime-unaware
identifier to perform non-`'static` downcasts directly.
[There is more information in this RFC PR,](https://github.com/rust-lang/rfcs/pull/1849)
for the curious. Note that the PR was accepted but then later removed, and was never
about non-`'static` downcasting; it was about a non-`'static` `type_id` method. The
idea was to get a "type" identifier that ignored lifetimes.
It was withdrawn in large part because if such a thing existed, [the chances of it
being abused in some wildly unsound way are about 100%.](https://internals.rust-lang.org/t/pre-rfc-non-footgun-non-static-typeid/17079/10)
An alternative (as presented in that thread) is to have some way to dynamically check
if two types (which are perhaps generic) are equal without imposing a `'static` bound.
The check could only be meaningful for types that were "inherently `'static`", that is,
types that do not involve any lifetime parameters at all. That would be possible
without actually exposing a non-`'static` `TypeId` or otherwise enabling downcasting.
The tradeoff results in pretty unintuitive behavior: `&'static str` cannot be
compared to `&'static str` with this approach, because there *is* a lifetime parameter
involved with `&str`!
Another alternative is to provide some sort of "type lambda" which is itself `'static`,
but can soundly map erased lifetimes back to their proper position. [A sketch is
provided here,](https://github.com/sagebind/castaway/pull/6#issuecomment-1150952050)
but an in-depth exploration is out of scope for this guide.
## A potential footgun around subtypes (subtitle: why not `const`?)
Let's take a minute to talk about types that *do* have a sub and supertype
relationship in Rust! Types which are [higher-ranked](./dyn-hr.md) have this
relationship. For example:
```rust
// More explicitly, this is a `for<'any> fn(&'any str)` function pointer.
// The type is higher-ranked over the lifetime.
let fp: fn(&str) = |_| {};
// This type is a supertype of the higher-ranked type.
let fp: fn(&'static str) = fp;
// This errors because you can't soundly downcast the types.
// let fp: fn(&str) = fp;
```
And as it turns out, it is possible for two Rust types which are more than
superficially syntactically different to be *subtypes of one another.* Some
parts of the language consider the existence of such a relationship to mean
that the two types are equal. Let's say they are semantically equal.
Below is an example. Due to covariance, it's always possible to call
either of the functions from the other, which helps explain why they are
considered subtypes of one another.
```rust
let one: for<'a > fn(&'a str, &'a str) = |_, _| {};
let two: for<'a, 'b> fn(&'a str, &'b str) = |_, _| {};
let mut fp = one;
fp = two;
let mut fp = two;
fp = one;
```
[However, these two types have different `TypeId`s!](https://github.com/rust-lang/rust/issues/97156)
So different parts of Rust currently disagree about what types are equal or not.
As the issue explains, this is a bit of a footgun if you were expecting consistency.
Additionally, it's a blocker for [a `const type_id` function](https://github.com/rust-lang/rust/issues/77125)
as it is possible to cause UB in safe code with a `const type_id` function so long
as this inconsistency remains.
How the language will evolve around this is unclear. People want the `const` feature
bad enough that [some version with caveats about false negatives](https://github.com/rust-lang/libs-team/issues/231)
may be pursued. Personally I feel making the type system consistent would be the
better solution and worth waiting for.
## More considerations around higher-ranked types
Even if the issue discussed above gets resolved and Rust becomes consistent about
what types are equal, [higher-ranked types](./dyn-hr.md) introduce some nuance to
be aware of. For example, when considering these two types:
```rust
trait Look<'s> {}
type HR = dyn for<'any> Look<'any> + 'static;
type ST = dyn Look<'static> + 'static;
```
`HR` is a *subtype* of `ST`, but not *the same type*.
However, they both satisfy a `'static` bound:
```rust
#trait Look<'s> {}
#type HR = dyn for<'any> Look<'any> + 'static;
#type ST = dyn Look<'static> + 'static;
fn assert_static<T: ?Sized + 'static>() {}
assert_static::<HR>();
assert_static::<ST>();
```
As `'static` types, they have `TypeId`s. As distinct types, their
`TypeId`s are different, even though one is a subtype of the other.
And this in turn means that you can't stop thinking about sub-and-super types
by simply applying a `'static` bound. If you need to "disable" sub/super type
coercions in a generic context for soundness, you must make that context invariant
or take other steps to avoid a soundness hole, even if you have a `'static` bound.
[See this issue](https://github.com/rust-lang/rust/issues/85863) for a real-life
example of such a soundness hole, and
[this comment in particular](https://github.com/rust-lang/rust/issues/85863#issuecomment-872536139)
exploring the sub/super type relationships of higher-ranked function pointers.
## The representation of `TypeId`
`TypeId` is intentionally opaque and subject to change. It was internally represented
by a `u64` for quite some time; as of Rust 1.72
[the representation is a `u128`.](https://github.com/rust-lang/rust/pull/109953)
At some future time it could be [something more exotic.](https://github.com/rust-lang/rust/pull/95845)
Long story short, you're not meant to rely on the exact representation of `TypeId`,
only it's type comparing properties.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Circle back
Ownership, borrowing, and lifetimes is a huge topic. There's way too much in this "intro" guide alone for you to absorb everything in it at once.
So occasionally circle back and revisit the common misconceptions, or the documentation on variance, or take another crack at some complicated problem you saw.
Your mental model will expand over time; it's enough in the beginning to know some things exist and revisit them when you run into a wall.
Moreover, Rust is practicality oriented, and the abilities of the compiler have developed organically to allow common patterns soundly and ergonomically.
Which is to say that the borrow checker has a fractal surface; there's an exception to any mental model of the borrow checker.
So there's always something new to learn, forget, and relearn, if you're into that.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Variance
The `dyn Trait` lifetime is covariant, like the outer lifetime of a
reference. This means that whenever it is in a covariant type position,
longer lifetimes can be coerced into shorter lifetimes.
```rust
# trait Trait {}
fn why_be_static<'a>(bx: Box<dyn Trait + 'static>) -> Box<dyn Trait + 'a> {
bx
}
```
The trait object with the longer lifetime is a subtype of the trait object with
the shorter lifetime, so this is a form of supertype coercion. [In the next
section,](./dyn-hr.md) we'll look at another form of trait object subtyping.
The idea behind *why* trait object lifetimes are covariant is that the lifetime
represents the region where it is still valid to call methods on the trait object.
Since it's valid to call methods anywhere in that region, it's also valid to restrict
the region to some subset of itself -- i.e. to coerce the lifetime to be shorter.
However, it turns out that the `dyn Trait` lifetime is even more flexible than
your typical covariant lifetime.
## Unsizing coercions in invariant context
[Earlier we noted that](./dyn-trait-coercions.md#the-reflexive-case)
you can cast a `dyn Trait + 'a` to a `dyn Trait + 'b`, where `'a: 'b`.
Well, isn't that just covariance? Not quite -- when we noted this before,
we were talking about an *unsizing coercion* between two `dyn Trait + '_`.
And *that coercion can take place even in invariant position.* That means
that the `dyn Trait` lifetime can act in a covariant-like fashion *even in
invariant contexts!*
For example, this compiles, even though the `dyn Trait` is behind a `&mut`:
```rust
# trait Trait {}
fn invariant_coercion<'m, 'long: 'short, 'short>(
arg: &'m mut (dyn Trait + 'long)
) ->
&'m mut (dyn Trait + 'short)
{
arg
}
```
But as there are [no nested unsizing coercions,](./dyn-trait-coercions.md#no-nested-coercions)
this version does not compile:
```rust,compile_fail
# trait Trait {}
fn foo<'l: 's, 's>(v: *mut Box<dyn Trait + 'l>) -> *mut Box<dyn Trait + 's> {
v
}
```
Because this is an unsizing coercion and not a subtyping coercion, there
may be situations where you must make the coercion explicitly, for example
with a cast.
```rust
# trait Trait {}
// This fails without the `as _` cast.
fn foo<'a>(arg: &'a mut Box<dyn Trait + 'static>) -> Option<&'a mut (dyn Trait + 'a)> {
true.then(move || arg.as_mut() as _)
}
```
### Why this is actually a critical feature
We'll examine elided lifetime in depth [soon,](./dyn-elision.md) but let us
note here how this "ultra-covariance" is very important for making common patterns
usably ergonomic.
The signatures of `foo` and `bar` are effectively the same in the following example:
```rust
# trait Trait {}
fn foo(d: &mut dyn Trait) {}
fn bar<'a>(d: &'a mut (dyn Trait + 'a)) {
foo(d);
foo(d);
}
```
We can call `foo` multiple times from `bar` by [reborrowing](./st-reborrow.md)
the `&'a mut dyn Trait` for shorter than `'a`. But because the trait object
lifetime must match the outer `&mut` lifetime in this case, *we also have
to coerce `dyn Trait + 'a` to that shorter lifetime.*
Similar considerations come into play when going between a `&mut Box<dyn Trait>`
and a `&mut dyn Trait`:
```rust
#trait Trait {}
#fn foo(d: &mut dyn Trait) {}
#fn bar<'a>(d: &'a mut (dyn Trait + 'a)) {
# foo(d);
# foo(d);
#}
fn baz(bx: &mut Box<dyn Trait /* + 'static */>) {
// If the trait object lifetime could not "shrink" inside the `&mut`,
// we could not make these calls at all
foo(&mut **bx);
bar(&mut **bx);
}
```
Here we reborrow `**bx` as `&'a mut (dyn Trait + 'static)` for some
short-lived `'a`, and then coerce that to a `&'a mut (dyn Trait + 'a)`.
## Variance in nested context
The supertype coercion of going from `dyn Trait + 'a` to `dyn Trait + 'b`
when `'a: 'b` *can* happen in deeply nested contexts, provided the trait
object is still in a covariant context. So unlike the `*mut` version
above, this version compiles:
```rust
# trait Trait {}
fn foo<'l: 's, 's>(v: *const Box<dyn Trait + 'l>) -> *const Box<dyn Trait + 's> {
v
}
```
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# `dyn Trait` lifetimes
As mentioned before, every `dyn Trait` has a "trait object lifetime". Even though
it is often elided, the lifetime is always present.
The lifetime is necessary as types which implement `Trait` may not be valid everywhere.
For example, `&'s String` implements `Display` for any lifetime `'s`. If you type
erase a `&'s String` into a `dyn Display`, Rust needs to keep track of that lifetime
so you don't try to print the value after the reference becomes invalid.
So you can coerce `&'s String` to `dyn Display + 's`, but not `dyn Display + 'static`.
Let's look at a couple examples:
```rust,compile_fail
# use core::fmt::Display;
fn fails() -> Box<dyn Display + 'static> {
let local = String::new();
// This reference cannot be longer than the function body
let borrow = &local;
// We can coerce it to `dyn Display`...
let bx: Box<dyn Display + '_> = Box::new(borrow);
// But the lifetime cannot be `'static`, so this is an error
bx
}
```
```rust
# use core::fmt::Display;
// This is fine as per the function lifetime elision rules, the lifetime of the
// `dyn Display + '_` is the same as the lifetime of the `&String`, and we know
// the reference is valid for that long or it wouldn't be possible to call the
// function.
fn works(s: &String) -> Box<dyn Display + '_> {
Box::new(s)
}
```
## When multiple lifetimes are involved
Let's try another example, with a `struct` that has more complicated lifetimes.
```rust
trait Trait {}
// We're using `*mut` to make the lifetimes invariant
struct MultiRef<'a, 'b>(*mut &'a str, *mut &'b str);
impl Trait for MultiRef<'_, '_> {}
fn foo<'a, 'b>(mr: MultiRef<'a, 'b>) {
let _: Box<dyn Trait + '_> = Box::new(mr);
}
```
This compiles, but there's nothing preventing either `'a` from being longer than `'b`,
or `'b` from being longer than `'a`. So what's the lifetime of the `dyn Trait`? It
can't be either `'a` or `'b`:
```rust,compile_fail
# trait Trait {}
# #[derive(Copy, Clone)] struct MultiRef<'a, 'b>(*mut &'a str, *mut &'b str);
# impl Trait for MultiRef<'_, '_> {}
// These both fail
fn foo<'a, 'b>(mr: MultiRef<'a, 'b>) {
let _: Box<dyn Trait + 'a> = Box::new(mr);
let _: Box<dyn Trait + 'b> = Box::new(mr);
}
```
In this case, the compiler computes some lifetime, let's call it `'c`,
such that `'a` and `'b` are both valid for the entirety of `'c`.
That is, `'c` is contained in an intersection of `'a` and `'b`.
Any lifetime for which both `'a` and `'b` are valid over will do:
```rust
# trait Trait {}
# struct MultiRef<'a, 'b>(*mut &'a str, *mut &'b str);
# impl Trait for MultiRef<'_, '_> {}
// `'c` must be within the intersection of `'a` and `'b`
fn foo<'a: 'c, 'b: 'c, 'c>(mr: MultiRef<'a, 'b>) {
let _: Box<dyn Trait + 'c> = Box::new(mr);
}
```
Note that this is not the same as `'a + 'b` -- that is the *union*
of `'a` and `'b`. Unfortunately, there is no compact syntax
for the intersection of `'a` and `'b`.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# The seed of a mental model
Some find it helpful to think of shared (`&T`) and exclusive (`&mut T`) references like so:
* `&T` is a compiler-checked `RwLockReadGuard`
* You can have as many of these at one time as you want
* `&mut T` is an compiler-checked `RwLockWriteGuard`
* You can only have one of these at one time, and when you do, you can have no `RwLockReadGuard`
The exclusivity is key.
`&mut T` are often called "mutable references" for obvious reasons. And following from that, `&T`
are often called "immutable references". However, I find it more accurate and consistent to call
`&mut T` an exclusive reference and to call `&T` a shared reference.
This guide doesn't yet cover shared mutability, more commonly called interior mutability, but you'll
run into the concept sometime in your Rust journey. The one thing I will mention here is that it
enables mutation behind a `&T`, and thus "immutable reference" is a misleading name.
There are other situations where the important quality of a `&mut T` is the exclusivity that it
guarantees, and not the ability to mutate through it. If you find yourself annoyed at getting
borrow errors about `&mut T` when you performed no actual mutation, it may help to instead
consider `&mut T` as a directive to the compiler to ensure *exclusive* access instead of
*mutable* access.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# `dyn Trait` coercions
Some `dyn Trait` coercions which are typical (in terms of what is being coerced) look like so:
```rust
# use std::sync::Arc;
# trait Trait {}
fn coerce_ref<'a, T: Trait + Sized + 'a>(t: &T ) -> &( dyn Trait + 'a) { t }
fn coerce_box<'a, T: Trait + Sized + 'a>(t: Box<T>) -> Box<dyn Trait + 'a> { t }
fn coerce_arc<'a, T: Trait + Sized + 'a>(t: Arc<T>) -> Arc<dyn Trait + 'a> { t }
// etc
```
These are more *syntactically noisy* than you will typically see in practice, as
I have included some explicit lifetimes and bounds which are normally implied
or not used. For example the `Sized` bound on generic type parameters
[is usually implied,](https://doc.rust-lang.org/reference/special-types-and-traits.html#sized)
but I've made it explicit to emphasize that we're talking about `Sized` base types.
The key point is that given an [object safe `Trait`,](dyn-safety.md) and when
`T: 'a + Trait + Sized`, you can coerce a `Ptr<T>` to a `Ptr<dyn Trait + 'a>`
for the supported `Ptr` pointer types such as `&_` and `Box<_>`.
If we had wanted a `dyn Trait + Send + 'a`, naturally we would need `T: Send`
as well, and similarly for any other auto trait.
In the rest of this section, we look at cases beyond these typical examples,
as well as some limitations of coercions.
## Associated types
When a trait has one or more non-generic associated type, every concrete implementor of
the trait chooses a single, statically-known type for each associated type. For base
types, this means the associated types are "outputs" of the implementing type and the
implemented trait: if you know the latter two, you can statically determine the
associated types as well.
So what should the associated types be in the implementation of `Trait` for
`dyn Trait`?
There is no single answer; they would need to vary based on the erased base types.
However, `dyn Trait` for traits with associated types is just too useful to
make traits with associated types inelligible for `dyn Trait`. Instead, associated
types in the trait become, in essence, named *type parameters* of the `dyn Trait`
type constructor. (Recall it's already a type constructor due to the trait object lifetime.)
So given
```rust
trait Iterator {
type Item;
fn next(&mut self) -> Option<Self::Item>;
}
```
We have
```rust,ignore
dyn Iterator<Item = String> + '_
dyn Iterator<Item = i32> + '_
dyn Iterator<Item = f64> + '_
```
and so on. The associated types in `dyn Trait<...>` must be resolved to
concrete types in order for the `dyn Trait<...>` to be a concrete type.
Naturally, you can only coerce to `dyn Iterator<Item = String>` if you
both implement `Iterator`, and in your implementation, `type Item = String`.
The syntax mirrors that of associated type trait bounds:
```rust
fn takes_string_iter<Iter>(i: Iter)
where
Iter: Iterator<Item = String>,
{
// ...
}
```
The parameters being named has a number of benefits. For one, it's
usually quite relevant, such as what `Item` an `Iterator` returns
(especially if the associated types are well named). It also removes
the need to order the associated types in a well-defined way, such as
lexicographically or especially declaration order (which would be too fragile).
The named parameters must be specified after all ordered parameters, however.
```rust
trait AssocAndParams<T, U> { type Assoc1; type Assoc2; }
// The trait's ordered type parameters must be in declaration order
// (here, `String` then `usize`). After that come the named associated
// type paramters, which can be reordered arbitrary amongst themselves.
fn foo(d: Box<dyn AssocAndParams<String, usize, Assoc1 = i32, Assoc2 = u32>>)
->
Box<dyn AssocAndParams<String, usize, Assoc2 = u32, Assoc1 = i32>>
{
d
}
```
## No nested coercions
An unsizing coercion needs to happen behind a layer of indirection (such as a
reference or in a `Box`) in order to accomodate the wide pointer to the erased
type's vtable (and because moving unsized types is not supported).
However, the unsizing coercion can only happen behind a *single* layer of
indirection. For example, you can't coerce a `Vec<Box<T>>` to a `Vec<Box<dyn Trait>>`.
Why not? `Box<T>` and `Box<dyn Trait>` have different layouts! The former
is the size of one pointer, while the second is the size of two pointers.
The entire `Vec` would need to be reallocated to accomodate such a change:
```rust
# trait Trait {}
fn convert_vec<'a, T: Trait + 'a>(v: Vec<Box<T>>) -> Vec<Box<dyn Trait + 'a>> {
v.into_iter().map(|bx| bx as _).collect()
}
```
In general, unsizing coercions consume the original pointer (reference, `Box`,
etc) and produce a new one, and this cannot happen in a nested context.
Internally, which coercions are possible are determined by the
[`CoerceUnsized`](https://doc.rust-lang.org/std/ops/trait.CoerceUnsized.html)
trait, and the (compiler-implemented) `Unsize` trait, as discussed in the
documentation.
## The `Sized` limitation
Base types must meet a `Sized` bound in order to be able to be coerced to
`dyn Trait`. For example, `&str` cannot be coerced to `&dyn Display`
even though `str` implements `Display`, because `str` is unsized.
Why is this limitation in place? `&str` is also a wide pointer; it consists
of a pointer to the UTF8 bytes, and a `usize` which is the number of bytes.
Similarly a slice reference `&[T]` is a pointer to the contiguous data, and
a count of the number of items.
A `&dyn Trait` created from a `&str` or `&[T]` would thus naively need to be
a "super-wide pointer", with a pointer to the data, the element count, *and*
the vtable pointer. But `&dyn Trait` is a concrete type with a static layout
-- two pointers -- so this naive approach can't work. Moreover, what if I
wanted to coerce a super-wide pointer? Each recursive coercion requires
another pointer, making the size unbounded.
A non-naive approach would require special-casing how dynamic dispatch
works for erased non-`Sized` base types. For example, once you've type
erased `str`, you've lost the information that `&str` is also a wide pointer,
and how to create that wide pointer. However, the code would need to recreate
a wide pointer in order to perform dynamic dispatch.
So for `dyn Trait` to non-naively support unsized types, it would need need
to examine at run-time how to construct a pointer to the erased base type:
one possibility for thin pointers, and an additional possibility for each type
of wide pointer supported.
Instead, unsized base types are simply not supported.
Sometimes you can work around the limitation by, for example, implementing
the trait for `&str` instead of `str`, and then coercing a `&'_ str` to
`dyn Trait + '_` (since references are always `Sized`).
```rust
# use std::fmt::Display;
// This fails as we cannot coerce `str` to `dyn Display`, so we cannot coerce
// `&str` to `&dyn Display`.
// let _: &dyn Display = "hi";
// However, `&str` also implements `Display`. (If `T: Display`, then `&T: Display`.)
// Because `&str` is `Sized`, we can instead coerce `&&str` to `&dyn Display`:
let _: &dyn Display = &"hi";
```
`Sized` is also used as a sort of "not-`dyn`" marker,
[which we explore later.](dyn-safety.md#the-sized-constraints)
There is one broad exception to the `Sized` limitation: coercing between
forms of `dyn Trait` itself, which we look at immediately below.
## Discarding auto traits
You can coerce a `dyn Trait + Send` to a `dyn Trait`, and similarly discard
any other auto trait.
Although
[`dyn Trait` isn't a supertype of `dyn Trait + Send`,](./dyn-trait-overview.md#dyn-trait-is-not-a-supertype)
this is nonetheless referred to as *upcasting* `dyn Trait + Send` to `dyn Trait`.
Note that auto traits have no methods, and thus no change to the vtable is
required for these coercions. They allow one to call a less restricted
function (that takes `dyn Trait`) from a more restrictive one (e.g. one that
requires `dyn Trait + Send`). The coercion is necessary as, again, these are
(distinct) concrete types, and not generics nor subtypes nor dynamic types.
Although no change to the vtable is required, this coercion can still
[not happen in a nested context.](#no-nested-coercions)
## The reflexive case
You can cast `dyn Trait` to `dyn Trait`.
Sorry, we're being too imprecise again. You can cast a `dyn Trait + 'a` to a `dyn Trait + 'b`,
where `'a: 'b`. This is important for
[how borrowing works with `dyn Trait + '_`.](./dyn-covariance.md#unsizing-coercions-in-invariant-context)
As lifetimes are erased during compilation, the vtable is the same regardless of the lifetime.
Despite that, this unsizing coercion can still [not happen in a nested context.](#no-nested-coercions)
However, [in a future section](http://127.0.0.1:3000/dyn-covariance.html) we'll see
how variance can allow shortening the trait object lifetime even in nested context,
provided that context is also covariant. [The section after that about higher-ranked
types](./dyn-hr.md) explores another lifetime-related coercion which could also be
considered reflexive.
## Supertrait upcasting
Though not supported on stable yet,
[the ability to upcast from `dyn SubTrait` to `dyn SuperTrait`](https://github.com/rust-lang/rust/issues/65991)
is a feature expected to be available some day.
It is, once again, explicitly a coercion and not a sub/super type relationship
(despite the terminology). Although this is an implementation detail, the
conversion will probably involve replacing the vtable pointer (in contrast
with the last couple of examples).
Until the feature is stable,
[you can write your own "manual" supertrait upcasts.](./dyn-trait-combining.md#manual-supertrait-upcasting)
## Object-safe traits only
There are other restrictions on the *trait* which we have not discussed here,
such as not (yet) supporting traits with generic associated types (GATs).
[We cover those in the next section.](dyn-safety.md)
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Borrowing something forever
An anti-pattern you may run into is to create a `&'a mut Thing<'a>`. It's an anti-pattern because it translates
into "take an exclusive reference of `Thing<'a>` for the entire rest of it's validity (`'a`)". Once you create
the exclusive borrow, you cannot use the `Thing<'a>` ever again, except via that borrow.
You can't call methods on it, you can't take another reference to it, you can't move it, you can't print it, you
can't use it at all. You can't even call a non-trivial destructor on it; if you have a non-trivial destructor,
your code won't compile in the presence of `&'a mut Thing<'a>`.
So avoid `&'a mut Thing<'a>`.
---
Examples:
```rust
#[derive(Debug)]
struct Node<'a>(&'a str);
fn example_1<'a>(node: &'a mut Node<'a>) {}
struct DroppingNode<'a>(&'a str);
impl Drop for DroppingNode<'_> { fn drop(&mut self) {} }
fn example_2<'a>(node: &'a mut DroppingNode<'a>) {}
fn main() {
let local = String::new();
let mut node_a = Node(&local);
// You can do this once and it's ok...
example_1(&mut node_a);
let mut node_b = Node(&local);
// ...but then you can't use the node directly ever again
example_1(&mut node_b);
println!("{node_b:?}");
let mut node_c = DroppingNode(&local);
// And this doesn't work at all
example_2(&mut node_c);
}
```
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Reference types
Let's open with a question: is `&str` a type?
When not being pendantic or formal, pretty much everyone will say yes, `&str` is a type.
However, it is technically a *type constructor* which is parameterized with a generic
lifetime parameter. So `&str` isn't technically a type, `&'a str` for some concrete
lifetime is a type.
Similarly, `Vec<T>` for a generic `T` is a type constructor, but `Vec<i32>` is a type.
By "concrete lifetime", I mean some compile-time determined lifetime. The exact
definition of "lifetime" is suprisingly complicated and beyond the scope of this
guide, but here are a few examples of `&str`s and their concrete types.
```rust
// The exact lifetime of `'a` is determined at each call site. We'll explore
// what this means in more depth later.
//
// The lifetime of `b` works the same, we just didn't give it a name.
fn example<'a>(a: &'a str, b: &str) {
// Literal strings are `&'static str`
let s = "literal";
// The lifetime of local borrows are determined by compiler analysis
// and have no names (but it's still a single lifetime).
let local = String::new();
let borrow = local.as_str();
// These are the same and they just tell the compiler to infer the
// lifetime. In this small example that means the same thing as not
// having a type annotation at all.
let borrow: &str = local.as_str();
let borrow: &'_ str = local.as_str();
}
```
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Influences from trait lifetime bounds
When the trait itself has lifetime bounds, those bounds may influence the
behavior of `dyn Trait` lifetime elision. Where and how the influence does
or does not take place is not properly documented, but we'll cover some
cases here.
The way trait object lifetime defaults behave in these scenarios is not
intuitive, and perhaps even arbitrary. But to be clear, you will probably
never need to actually know the exact rules. Traits with exotic lifetime
bounds are rare, and should you actually encounter one, you can usually
choose to be explicit instead of trying to figure out what lifetime is
the default when elided.
Which is to say, this subsection is more of an exploration of the
compiler's current behavior than something useful to learn. If you're
trying to learn practical Rust, you should probably just skip it.
A very high level summary is:
- Trait bounds introduce implied bounds on the trait object lifetimes
- Elision in the presence of non-`'static` trait lifetime bounds is arbitrary, so prefer to be explicit
- Prefer not to add non-`'static` lifetime bounds to your own object safe traits
- Avoid multiple lifetime bounds in particular
This section is also non-exhaustive. Given how many exceptions I have ran across,
take my assertive statements in this section with a grain of salt.
## Trait lifetime bounds create an implied bound
The trait bound creates an implied bound on the `dyn Trait` lifetime:
```rust
pub trait LifetimeTrait<'a, 'b>: 'a {}
pub fn f<'b>(_: Box<dyn LifetimeTrait<'_, 'b> + 'b>) {}
fn fp<'a, 'b, 'c>(t: Box<dyn LifetimeTrait<'a, 'b> + 'c>) {
// This compiles which indicates an implied `'c: 'a` bound
let c: &'c [()] = &[];
let _: &'a [()] = c;
// This does not, demonstrating that `'c: 'b` is not implied
// (i.e. the implied bound is on the trait object lifetime only, and
// not on the other parameters.)
//let _: &'b [()] = c;
// This does not as it requires `'c: 'b` and `'b: 'a`
//f(t);
}
```
This is similar to how `&'b &'a _` creates an implied `'a: 'b` bound.
It only applies to the trait object lifetime, and not the entirety
of the `dyn Trait` (e.g. it does not apply to trait parameters).
## The `'static` case
We've already summarized the behavior of trait object lifetime elision when
the trait itself has a `'static` bound as part of our basic guidelines: the
lifetime in this case is always `'static`.
This applies even to
- types with ambiguous (more than one) lifetime bounds
- types with a single lifetime bound like `&_`
- i.e. the trait object lifetime (which is `'static`) becomes independent of the outer lifetime
- situations where a non-`'static` bound does *not* override the `&_` trait object lifetime default, as in some of the examples further below
This case applies even if there are multiple bounds and only one of them is
`'static`, in contrast with
[bounds considered ambiguous from the struct definition.](./dyn-elision-advanced.md#ambiguous-bounds)
## A single trait lifetime bound does not always apply
According to the reference, the default trait object lifetime for a trait
with a single lifetime bound in the context of a generic struct with no
lifetime bounds is always the lifetime in the trait's bound.
That's a mouthful, but the implication is that here:
```rust
trait Single<'a>: 'a {}
```
The elided lifetime of `Box<dyn Single<'a>>` is always `'a`.
However, this is not actually the case:
```rust
#trait Single<'a>: 'a {}
// The elided lifetime was `'static`, not `'a`, so this compiles
fn foo<'a>(s: Box<dyn Single<'a>>) {
let s: Box<dyn Single<'a> + 'static> = s;
}
```
```rust,compile_fail
#trait Single<'a>: 'a {}
// In this case it *is* `'a`, so compilation fails
fn bar<'a: 'a>(s: Box<dyn Single<'a>>) {
let s: Box<dyn Single<'a> + 'static> = s;
}
```
## When they apply, trait lifetime bounds override struct bounds
According to the reference, bounds on the trait never override bounds on
the struct. But based on my testing, the opposite is true: *when* bounds
on the trait apply, they *always* override the bounds on the struct.
The complicated part is figuring out when they apply.
For example, the following compiles, but according to the reference it
should be ambiguous due to the multiple lifetime bounds on the struct.
It does not compile without the lifetime bound on the trait; the bound
on the trait is overriding the ambiguous bounds on the struct.
```rust
use core::marker::PhantomData;
// Remove `: 'a` to see the compile error
pub trait LifetimeTrait<'a>: 'a {}
pub struct Over<'a, T: 'a + 'static + ?Sized>(&'a T);
pub struct Invariant<T: ?Sized>(*mut PhantomData<T>);
unsafe impl<T: ?Sized> Sync for Invariant<T> {}
pub static OS: Invariant<Over<'_, dyn LifetimeTrait>> = Invariant(std::ptr::null_mut());
```
Further below are some examples where the trait bound overrides the
`&_` bounds as well, so it is not just ambiguous struct bounds which can
be overridden by trait bounds.
## Multiple trait bounds can be ambiguous or can apply
The following is considered ambiguous due to the multiple lifetime bounds
on the trait.
```rust,compile_fail
trait Double<'a, 'b>: 'a + 'b {}
fn f<'a, 'b, T: Double<'a, 'b> + 'static>(t: T) {
let bx: Box<dyn Double<'a, 'b>> = Box::new(t);
// This version works:
let bx: Box<dyn Double<'a, 'b> + 'static> = Box::new(t);
}
```
The current documentation is silent on this point, but a multiple-bound
trait can still apply in such a way that it provides the default trait
object lifetime.
```rust
pub trait Double<'a, 'b>: 'a + 'b {}
fn x1<'a: 'a, 'b>(bx: Box<dyn Double<'a, 'b>>) {
// This fails (the lifetime is not `'static`)
//let bx: Box<dyn Double<'a, 'b> + 'static> = bx;
// This also fails (the lifetime is not `'b` nor `'a + 'b`)
//let bx: Box<dyn Double<'a, 'b> + 'b> = bx;
// But this succeeds and we can conclude the lifetime is `'a`
let bx: Box<dyn Double<'a, 'b> + 'a> = bx;
}
```
There's a subtle point here: the elided trait object lifetime is `'a`,
but there's an implied `: 'a + 'b` bound on the trait object lifetime
due to the trait bounds. Therefore the function signature has an
implied `'a: 'b` bound, similar to when you have a `&'b &'a _`
argument.
## Trait bounds *always* apply in function bodies
Based on my testing, the default trait object lifetime for annotations
of `dyn Trait` in function bodies is *always* the trait bound. And in
fact, this bound *even overrides the wildcard `'_` lifetime annotation*.
This is a surprising exception to the `'_` annotation restoring "normal"
lifetime elision behavior.
```rust,compile_fail
trait Single<'a>: 'a {}
fn baz<'long: 'a, 'a, T: 'long + Single<'a>>(s: T) {
// This compiles with the assignment at the end:
//let s: Box<dyn Single<'a> + 'long> = Box::new(s);
// But none of these compile because `'a: 'long` does not hold:
//let s: Box<dyn Single<'a>> = Box::new(s);
//let s: Box<dyn Single<'_>> = Box::new(s);
//let s: Box<dyn Single<'a> + '_> = Box::new(s);
//let s: Box<dyn Single<'_> + '_> = Box::new(s);
//let s: Box<dyn Single + '_> = Box::new(s);
let s: Box<dyn Single> = Box::new(s);
let s: Box<dyn Single<'_> + 'long> = s;
}
```
## When and how to trait lifetime bounds apply?
Now that we've seen a number of examples, we can theorize when and how
trait lifetime bounds apply. As the examples have already illustrated,
there are very different rules for different contexts.
### In function signatures
This appears to be the most complex and arbitrary context for trait object lifetime elision.
If you were paying close attention, you may have noticed that we occasionally had
trivial bounds like `'a: 'a` in the examples above, and that affected whether the
trait bounds applied or not. A lifetime parameter of a function with no
*explicit* bounds is known as a late-bound parameter, and
[whether or not a lifetime is late-bound influences when the trait bounds apply
in function signatures.](https://github.com/rust-lang/rust/issues/47078)
Parameters which are not late-bound are early-bound.
Let us call a lifetime parameter of a trait which is also a bound of the trait
a "bounding parameter". My hypothesis on the behavior is as follows:
- if any trait bound is `'static`, the default lifetime is `'static`
- if any bounding parameter is explicitly `'static`, the default lifetime is `'static`
- if exactly one bounding parameter is early-bound, the default lifetime is that lifetime
- including if it is in multiple positions, such as `dyn Double<'a, 'a>`
- if more than one bounding parameter is early-bound, the default lifetime is ambiguous
- if no bounding parameters are early-bound, the default lifetime depends on the `struct`
bounds (the same as they do for a trait without bounds)
Note that in any case, the implied bounds on the trait object lifetime
that exist due to the trait bounds are still in effect.
The requirement that exactly one of the bounding parameters is early-bound
or that any of them are `'static` are syntactical requirements, rather than
semantic ones. For example:
```rust,compile_fail
pub trait Double<'a, 'b>: 'a + 'b {}
// Semantically, `'a` and `'b` must be `'static`. However the
// parameters were not explicitly `'static` and thus this
// trait object lifetime is considered ambiguous (even though,
// due to the implied bounds, it must be `'static` too).
fn foo<'a: 'static, 'b: 'static>(d: Box<dyn Double<'a, 'b>>) {}
// Semantically, `'a` and `'b` must be the same. They are also
// early-bound parameters due to the bounds. However the parameters
// are not syntatically the same lifetime and thus this trait
// object lifetime is considered ambiguous.
fn bar<'a: 'b, 'b: 'a>(d: &dyn Double<'a, 'b>) {}
```
But if you change either example to `Double<'a, 'a>`, then
exactly one of the bounding parameters is early-bound, and they
will compile:
```rust
#pub trait Double<'a, 'b>: 'a + 'b {}
fn foo<'a: 'static, 'b: 'static>(d: Box<dyn Double<'a, 'a>>) {}
fn bar<'a: 'b, 'b: 'a>(d: &dyn Double<'a, 'a>) {}
```
#### Implicit bounds do not negate being late-bound
Note that when considering `&dyn Trait` there is always an *implied* bound between the
outer reference's lifetime and the `dyn Trait` (in addition to the implied bound from
the trait itself). However, these implied bounds are not enough to make the trait
bound apply on their own. A lifetime can be late-bound even when there are implied bounds.
```rust
pub trait LifetimeTrait<'a>: 'a {}
impl LifetimeTrait<'_> for () {}
// All of these compile with the `fp` function below, indicating that
// the trait bound does in fact apply and results in a trait object
// lifetime independent of the reference lifetime
pub fn f<'a: 'a>(_: &dyn LifetimeTrait<'a>) {}
//pub fn f<'a: 'a>(_: &'_ dyn LifetimeTrait<'a>) {}
//pub fn f<'r, 'a: 'a>(_: &'r dyn LifetimeTrait<'a>) {}
//pub fn f<'r: 'r, 'a: 'a>(_: &'r dyn LifetimeTrait<'a>) {}
//pub fn f<'r, 'a: 'r + 'a>(_: &'r dyn LifetimeTrait<'a>) {}
//pub fn f<'r: 'r, 'a: 'r>(_: &'r dyn LifetimeTrait<'a>) {}
// However none of these compile with `fp`, indicating that the elided trait
// object lifetime is defaulting to the reference lifetime "per normal".
//pub fn f(_: &dyn LifetimeTrait) {}
//pub fn f(_: &'_ dyn LifetimeTrait) {}
//pub fn f<'r>(_: &'r dyn LifetimeTrait) {}
//pub fn f<'r: 'r>(_: &'r dyn LifetimeTrait) {}
//pub fn f(_: &dyn LifetimeTrait<'_>) {}
//pub fn f(_: &'_ dyn LifetimeTrait<'_>) {}
//pub fn f<'r>(_: &'r dyn LifetimeTrait<'_>) {}
//pub fn f<'r: 'r>(_: &'r dyn LifetimeTrait<'_>) {}
//pub fn f<'a>(_: &dyn LifetimeTrait<'a>) {}
//pub fn f<'a>(_: &'_ dyn LifetimeTrait<'a>) {}
//pub fn f<'r, 'a>(_: &'r dyn LifetimeTrait<'a>) {}
//pub fn f<'r: 'r, 'a>(_: &'r dyn LifetimeTrait<'a>) {}
// n.b. `'a` is invariant due to being a trait parameter
fn fp<'a>(t: &(dyn LifetimeTrait<'a> + 'a)) {
f(t);
}
```
The above examples also demonstrate that when trait bounds apply,
they do override non-ambiguous struct bounds (such as those of `&_`).
#### Implied bounds and default object bounds interact
The interaction between what the default object lifetime is for a given
signature can interact in potentially surprising ways. Consider this example:
```rust
#pub trait LifetimeTrait<'a>: 'a {}
// The implied bounds in `&'outer (dyn Lifetime<'param> + 'trait)` are:
// - `'param: 'outer` (validity of the reference)
// - `'trait: 'outer` (validity of the reference)
// - `'trait: 'param` (from the trait bound)
//
// And as the trait bound does not apply to the elided parameter in this
// case, we also have `'outer = 'trait` due to the "normal" default
// lifetime behavior of `&_`. Adding that equality to the above bounds
// results in a requirement that *all three lifetimes are the same*.
//
// And thus this compiles:
pub fn g<'r, 'a>(d: &'r dyn LifetimeTrait<'a>) {
let r: [&'r (); 1] = [&()];
let a: [&'a (); 1] = [&()];
let _: [&'a (); 1] = r;
let _: [&'r (); 1] = a;
let _: &'r (dyn LifetimeTrait<'r> + 'r) = d;
let _: &'a (dyn LifetimeTrait<'a> + 'a) = d;
}
```
The results can be even more surprising with more complex bounds:
```rust
trait Double<'a, 'b>: 'a + 'b {}
fn h<'a, 'b, T>(bx: Box<dyn Double<'a, 'b>>, t: &'a T)
where
&'a T: Send, // this makes `'a` early-bound
{
// `bx` is `Box<dyn Double<'a, 'b> + 'a>` as per the rules above,
// so this does not compile:
//let _: Box<dyn Double<'a, 'b> + 'static> = bx;
// However, the implied bounds still apply, which means:
// - `'a: 'a + 'b`
// - So `'a: 'b`
//
// Which is why this can compile even though that bound
// is not declared anywhere!
let t: &'b T = t;
// The lifetimes are still not the same, so this fails
let _: &'a T = t;
}
```
The only reason that `'a: 'b` is an implied bound in the above example
is the interaction between
- the implied `: 'a + 'b` bound on the trait object lifetime
- the default trait object lifetime being `'a`
- due to `'a` being early-bound and `'b` being late-bound
If `'b` was also early-bound, the default trait object lifetime would
be ambiguous. If `'a` wasn't early-bound, the default trait object
lifetime would be `'static` and there would be no implied `'a: 'b`
bound.
#### The wildcard lifetime still introduces a fresh inference lifetime
Based on my testing, using `'_` will behave like typical lifetime elision,
introducing a fresh inference lifetime in input position, and following
the function signature elision rules in output position.
#### Higher-ranked lifetimes are late-bound
Based on my testing, `for<'a> dyn Trait...` lifetimes act the same as
late-bound lifetimes.
### Function bodies
As mentioned above, trait object bounds always apply in function bodies,
similar to function signatures where every lifetime is early-bound. This
is true irregardless of whether the lifetimes are early or late bound in
the function signature.
```rust
trait Single<'a>: 'a {}
fn foo<'r, 'a>(bx: Box<dyn Single<'a> + 'static>, rf: &'r (dyn Single<'a> + 'static)) {
// Here it is `'a`, and not `'static` nor inferred
let bx: Box<dyn Single<'a>> = bx;
// So this fails
//let _: Box<dyn Single<'a> + 'static> = bx;
// Here it is `'a`, and not the same as the reference lifetime nor inferred
let a: &dyn Single<'a> = rf;
// So this succeeds
let _: &(dyn Single<'a> + 'a) = a;
// And this fails
//let _: &(dyn Single<'a> + 'static) = a;
// Same behavior when the reference lifetime is explicit
let a: &'r dyn Single<'a> = rf;
let _: &'r (dyn Single<'a> + 'a) = a;
//let _: &'r (dyn Single<'a> + 'static) = a;
// This also fails, demonstrating that `'r` is not `'a`
//let _: &'a &'r () = &&();
}
```
And unlike elsewhere, using `'_` in place of complete trait object
lifetime elision in the function body does not restore the normal
lifetime elision behavior (which would be inferring the lifetime).
All three of the examples above behave identically if `'_` is used.
```rust
#trait Single<'a>: 'a {}
fn foo<'r, 'a>(bx: Box<dyn Single<'a> + 'static>, rf: &'r (dyn Single<'a> + 'static)) {
let bx: Box<dyn Single<'a> + '_> = bx;
// Fails
//let _: Box<dyn Single<'a> + 'static> = bx;
let a: &(dyn Single<'a> + '_) = rf;
let _: &(dyn Single<'a> + 'a) = a;
// Fails
//let _: &(dyn Single<'a> + 'static) = a;
let a: &'r (dyn Single<'a> + '_) = rf;
let _: &'r (dyn Single<'a> + 'a) = a;
// Fails
//let _: &'r (dyn Single<'a> + 'static) = a;
}
```
In combination with the behavior of function signatures, this can
lead to some awkward situations.
```rust,compile_fail
trait Double<'a, 'b>: 'a + 'b {}
// Here in the signature, `'_` acts like "normal" and creates an
// independent lifetime for the trait object lifetime; let us call
// it `'c`. Though independent, it is related due to the implied
// bounds: `'c: 'a + 'b`
fn foo<'a, 'b>(bx: Box<dyn Double<'a, 'b> + '_>) {
// Here in the body, the default trait object lifetime is
// considered ambiguous, and `'_` does not override this.
//
// Moreover, there is no way to name `'c` since it was
// elided in the signature. We could annotate this as
// either `'a` or `'b`, but cannot "preserve" the full
// lifetime unless we change the function signature to
// give the lifetime a name.
let bx: Box<dyn Double<'a, 'b> + '_> = bx;
}
```
### Static contexts
In most static contexts, any elided lifetimes (not just trait object
lifetimes) default to the `'static` lifetime.
```rust
#use core::marker::PhantomData;
trait Single<'a>: 'a + Send + Sync {}
trait Halfie<'a, 'b>: 'a + Send + Sync {}
trait Double<'a, 'b>: 'a + 'b + Send + Sync {}
static BS: PhantomData<Box<dyn Single<'_>>> = PhantomData;
static BH: PhantomData<Box<dyn Halfie<'_, '_>>> = PhantomData;
static BD: PhantomData<Box<dyn Double<'_, '_>>> = PhantomData;
static S_BS: PhantomData<Box<dyn Single<'static> + 'static>> = BS;
static S_BH: PhantomData<Box<dyn Halfie<'static, 'static> + 'static>> = BH;
static S_BD: PhantomData<Box<dyn Double<'static, 'static> + 'static>> = BD;
const CS: PhantomData<Box<dyn Single<'_>>> = PhantomData;
const CH: PhantomData<Box<dyn Halfie<'_, '_>>> = PhantomData;
const CD: PhantomData<Box<dyn Double<'_, '_>>> = PhantomData;
const S_CS: PhantomData<Box<dyn Single<'static> + 'static>> = CS;
const S_CH: PhantomData<Box<dyn Halfie<'static, 'static> + 'static>> = CH;
const S_CD: PhantomData<Box<dyn Double<'static, 'static> + 'static>> = CD;
```
In a context where non-`'static` lifetimes can be named, those lifetimes
act like early-bound lifetimes in function signatures.
```rust
#use core::marker::PhantomData;
#trait Single<'a>: 'a + Send + Sync {}
struct L<'l, 'm>(&'l str, &'m str);
impl<'a, 'b> L<'a, 'b> {
const CS: PhantomData<Box<dyn Single<'a>>> = PhantomData;
// Fails
//const S_CS: PhantomData<Box<dyn Single<'a> + 'static>> = Self::CS;
const S_CS: PhantomData<Box<dyn Single<'a> + 'a>> = Self::CS;
}
```
Elided lifetimes are still inferred to be `'static`...
```rust
#use core::marker::PhantomData;
#trait Single<'a>: 'a + Send + Sync {}
#struct L<'l, 'm>(&'l str, &'m str);
impl<'a, 'b> L<'a, 'b> {
const ECS: PhantomData<Box<dyn Single<'_>>> = PhantomData;
const SCS: PhantomData<Box<dyn Single<'static>>> = PhantomData;
const S_ECS: PhantomData<Box<dyn Single<'static> + 'static>> = Self::ECS;
const S_SCS: PhantomData<Box<dyn Single<'static> + 'static>> = Self::SCS;
}
```
*...however,* this inference only seems to take effect after the
definition itself for elided trait object lifetimes, as demonstrated
by cases such as this being ambiguous:
```rust
#use core::marker::PhantomData;
#trait Double<'a, 'b>: 'a + 'b + Send + Sync {}
#struct L<'l, 'm>(&'l str, &'m str);
impl<'a, 'b> L<'a, 'b> {
const EBCD: PhantomData<Box<dyn Double<'a, '_>>> = PhantomData;
}
```
...and cases such this saying that the reference lifetime is longer
than the trait object, even when they have the same anonymous
lifetime:
```rust
#use core::marker::PhantomData;
#trait Single<'a>: 'a + Send + Sync {}
struct R<'l, 'm, 'r>(&'l str, &'m str, &'r ());
impl<'a, 'b, 'r> R<'a, 'b, 'r> where 'a: 'r, 'b: 'r {
const ECS: PhantomData<&dyn Single<'_>> = PhantomData;
const RECS: PhantomData<&'r dyn Single<'_>> = PhantomData;
}
```
### `impl` headers
Trait bounds always apply in `impl` headers.
```rust
trait Single<'a>: 'a {}
trait Halfie<'a, 'b>: 'a {}
trait Double<'a, 'b>: 'a + 'b {}
struct S<T>(T);
// The trait bounds apply
impl<'a> S<Box<dyn Single<'a>>> { fn f01() {} } // 'a (not 'static)
impl<'a, 'r> S<&'r dyn Single<'a>> { fn f02() {} } // 'a (not 'r)
impl<'a, 'b> S<Box<dyn Halfie<'a, 'b>>> { fn f03() {} } // 'a (not 'static)
impl<'a, 'b, 'r> S<&'r dyn Halfie<'a, 'b>> { fn f04() {} } // 'a (not 'r)
// Ambiguous (uncomment for error)
// impl<'a, 'b> S<Box<dyn Double<'a, 'b>>> { fn f05() {} }
// impl<'a, 'b, 'r> S<&'r dyn Double<'a, 'b>> { fn f05() {} }
// Try `+ 'static` or `+ 'r` for errors
fn f<'a, 'b, 'r>(_: &'r &'a str, _: &'r &'b str) {
S::<Box<dyn Single<'a> + 'a>>::f01();
S::<&'r (dyn Single<'a> + 'a)>::f02();
S::<Box<dyn Halfie<'a, 'b> + 'a>>::f03();
S::<&'r (dyn Halfie<'a, 'b> + 'a)>::f04();
}
```
As in function signatures, but unlike function bodies, the wildcard lifetime
`'_` acts like normal elision (introducing a new anonymous lifetime variable).
```rust
#trait Single<'a>: 'a {}
#trait Halfie<'a, 'b>: 'a {}
#trait Double<'a, 'b>: 'a + 'b {}
#struct S<T>(T);
// The wildcard lifetime `'_` introduces an independent lifetime
// (covering all cases including `'static`) as per normal
impl<'a> S<Box<dyn Single<'a> + '_>> { fn f26() {} }
impl<'a, 'r> S<&'r (dyn Single<'a> + '_)> { fn f27() {} }
impl<'a, 'b> S<Box<dyn Halfie<'a, 'b> + '_>> { fn f28() {} }
impl<'a, 'b, 'r> S<&'r (dyn Halfie<'a, 'b> + '_)> { fn f29() {} }
impl<'a, 'b> S<Box<dyn Double<'a, 'b> + '_>> { fn f30() {} }
impl<'a, 'b, 'r> S<&'r (dyn Double<'a, 'b> + '_)> { fn f31() {} }
fn f<'a, 'b, 'r>(_: &'r &'a str, _: &'r &'b str) {
S::<Box<dyn Single<'a> + 'static>>::f26();
S::<&'r (dyn Single<'a> + 'static)>::f27();
S::<Box<dyn Halfie<'a, 'b> + 'static>>::f28();
S::<&'r (dyn Halfie<'a, 'b> + 'static)>::f29();
S::<Box<dyn Double<'a, 'b> + 'static>>::f30();
S::<&'r (dyn Double<'a, 'b> + 'static)>::f31();
}
```
### Associated types
Similar to `impl` headers, trait bounds always apply to associated types.
```rust
#use core::marker::PhantomData;
trait Single<'a>: 'a {}
trait Halfie<'a, 'b>: 'a {}
trait Double<'a, 'b>: 'a + 'b {}
trait Assoc {
type A01: ?Sized + Default;
type A02: ?Sized + Default;
//type A03: ?Sized + Default;
type A04: ?Sized + Default;
type A05: ?Sized + Default;
//type A06: ?Sized + Default;
}
impl<'r, 'a, 'b> Assoc for (&'r &'a (), &'r &'b ()) {
// '_ is not allowed here
// & /* elided */ is not allowed here
type A01 = PhantomData<Box<dyn Single<'a>>>;
type A02 = PhantomData<Box<dyn Halfie<'a, 'b>>>;
// ambiguous
// type A03 = PhantomData<Box<dyn Double<'a, 'b>>>;
type A04 = PhantomData<&'r dyn Single<'a>>;
type A05 = PhantomData<&'r dyn Halfie<'a, 'b>>;
// ambiguous
// type A06 = PhantomData<&'r dyn Double<'a, 'b>>;
}
fn f<'r, 'a: 'r, 'b: 'r>() {
// 'a (not `'static`, `'r`, `'b`)
let _: PhantomData<Box<dyn Single<'a> + 'a>> = <(&'r &'a (), &'r &'b ()) as Assoc>::A01::default();
let _: PhantomData<Box<dyn Halfie<'a, 'b> + 'a>> = <(&'r &'a (), &'r &'b ()) as Assoc>::A02::default();
let _: PhantomData<&'r (dyn Single<'a> + 'a)> = <(&'r &'a (), &'r &'b ()) as Assoc>::A04::default();
let _: PhantomData<&'r (dyn Halfie<'a, 'b> + 'a)> = <(&'r &'a (), &'r &'b ()) as Assoc>::A05::default();
}
```
Note: I have not performed extensive tests with GATs or associated types which themselves
have lifetime bounds in combination with bounded traits.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Bound-related lifetimes "infect" each other
Separating `'a` and `'b` in the last section didn't make things any more flexible in terms of `self` being borrowed.
Once you declare a bound like `'a: 'b`, then the two lifetimes "infect" each other.
Even though the return type had a different lifetime than the input, it was still effectively a reborrow of the input.
This can actually happen between two input parameters too: if you've stated a lifetime relationship between two borrows,
the compiler assumes they can observe each other in some sense. It's probably not anything you'll run into soon,
but if you do, the compiler errors tend to be drop errors ("borrow might be used here, when `x` is dropped"), or
sometimes read like "data flows from X into Y".
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Non-references
The variance of lifetime and type parameters of your own `struct`s is automatically
inferred from how you use those parameters in your field. For example if you have a
```rust
struct AllMine<'a, T>(&'a mut T);
```
Then `AllMine` is covariant in `'a` and invariant in `T`, just like `&'a mut T` is.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Get a feel for variance, references, and reborrows
[Here's some official docs on the topic of variance,](https://doc.rust-lang.org/reference/subtyping.html)
but reading it may make you go cross-eyed. As an alternative, in this section I attempt to introduce some basic
rules about how references work with regard to lifetimes over the course of a few layers.
If it still makes you cross-eyed, just skim or skip ahead.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Quine Zine: Learning Rust
[Introduction](README.md)
---
# Practical suggestions for building intuition around borrow errors
- [Sectional introduction](lifetime-intuition.md)
- [Keep at it and participate in the community](community.md)
- [Prefer ownership over long-lived references](have-no-life.md)
- [Don't hide lifetimes](dont-hide.md)
- [Understand elision and get a feel for when to name lifetimes](elision.md)
- [Get a feel for variance, references, and reborrows](subtypes.md)
- [The seed of a mental model](st-model.md)
- [Reference types](st-types.md)
- [Lifetime bounds](st-bounds.md)
- [Reference lifetimes](st-references.md)
- [Copy and reborrows](st-reborrow.md)
- [Nested borrows and invariance](st-invariance.md)
- [Invariance elsewhere](st-more-invariance.md)
- [Non-references](st-non-references.md)
- [Get a feel for borrow-returning methods](methods.md)
- [When not to name lifetimes](m-naming.md)
- [Bound-related lifetimes "infect" each other](m-infect.md)
- [`&mut` inputs don't "downgrade" to `&`](m-no-downgrades.md)
- [Understand function lifetime parameters](fn-parameters.md)
- [Understand borrows within a function](lifetime-analysis.md)
- [Learn some pitfalls and antipatterns](pitfalls.md)
- [`dyn Trait` lifetimes and `Box<dyn Trait>`](pf-dyn.md)
- [Conditional return of a borrow](pf-nll3.md)
- [Borrowing something forever](pf-borrow-forever.md)
- [`&'a mut self` and `Self` aliasing more generally](pf-self.md)
- [Avoid self-referential structs](pf-meta.md)
- [Scrutinize compiler advice](compiler.md)
- [Advice to change function signature when aliases are involved](c-signatures.md)
- [Advice to add bound which implies lifetime equality](c-equality.md)
- [Advice to add a static bound](c-static.md)
- [Circle back](circle.md)
---
# A tour of `dyn Trait`
- [Sectional introduction](dyn-trait.md)
- [`dyn Trait` overview](dyn-trait-overview.md)
- [`dyn Trait` implementations](dyn-trait-impls.md)
- [`dyn Trait` coercions](dyn-trait-coercions.md)
- [`dyn` safety (object safety)](dyn-safety.md)
- [`dyn Trait` lifetimes](dyn-trait-lifetime.md)
- [Variance](dyn-covariance.md)
- [Higher-ranked types](dyn-hr.md)
- [Elision rules](dyn-elision.md)
- [Basic guidelines](dyn-elision-basic.md)
- [Advanced guidelines](dyn-elision-advanced.md)
- [Trait bound interactions](dyn-elision-trait-bounds.md)
- [Citations](dyn-elision-citations.md)
- [`dyn Trait` vs. alternatives](dyn-trait-vs.md)
- [`dyn Trait` examples](dyn-trait-examples.md)
- [Combining traits](dyn-trait-combining.md)
- [`impl Trait for Box<dyn Trait>`](dyn-trait-box-impl.md)
- [Cloneable `Box<dyn Trait>`](dyn-trait-clone.md)
- [`dyn PartialEq`](dyn-trait-eq.md)
- [Generalizing borrows](dyn-trait-borrow.md)
- [Erased traits](dyn-trait-erased.md)
- [`dyn Any`](dyn-any.md)
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Advice to add a static bound
The compiler is gradually getting better about this, but when it suggests to use a `&'static` or that a lifetime needs to outlive `'static`, it usually *actually* means either
* You're in a context where non-`'static` references and other non-`static` types aren't allowed
* You should add a lifetime parameter somewhere
Rather than try to cook up my own example, [I'll just link to this issue.](https://github.com/rust-lang/rust/issues/50212)
Although it's closed, there's still room for improvement in some of the examples within.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Nested borrows and invariance
Now let's consider nested references:
* A `&'medium &'long U` coerces to a `&'short &'short U`
* A `&'medium mut &'long mut U` coerces to a `&'short mut &'long mut U`...
* ...but *not* to a `&'short mut &'short mut U`
We say that `&mut T` is *invariant* in `T`, which means any lifetimes in `T` cannot change
(grow or shrink) at all. In the example, `T` is `&'long mut U`, and the `'long` cannot be changed.
Why not? Consider this:
```rust
fn bar(v: &mut Vec<&'static str>) {
let w: &mut Vec<&'_ str> = v; // call the lifetime 'w
let local = "Gottem".to_string();
w.push(&*local);
} // `local` drops
```
If `'w` was allowed to be shorter than `'static`, we'd end up with a dangling reference in `*v` after `bar` returns.
You will inevitably end up with a feel for covariance from using references with their flexible outer lifetimes,
but eventually hit a use case where invariance matters and causes some borrow check errors, because it's (necessarily) so much less flexible.
It's just part of the Rust learning experience.
---
Let's look at one more property of nested references you may run into:
* You can get a `&'long U` from a `&'short &'long U`
* Just copy it out!
* But you cannot get a `&'long mut U` from a `&'short mut &'long mut U`
* You can only reborrow a `&'short mut U`
The reason is again to prevent memory unsafety.
Additionally,
* You cannot get a `&'long U` or *any* `&mut U` from a `&'short &'long mut U`
* You can only reborrow a `&'short U`
Recall that once a shared reference exist, any number of copies of it could
simultaneously exist. Therefore, so long as the outer shared reference exists
(and could be used to observe `U`), the inner `&mut` must not be usable in a
mutable or otherwise exclusive fashion.
And once the outer reference expires, the inner `&mut` is active and must
again be exclusive, so it must not be possible to obtain a `&'long U` either.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Elision rules
The `dyn Trait` lifetime elision rules are an instance of fractal complexity
in Rust. Some general guidelines will get you 95% of the way there, some
advanced guidelines will get you another 4% of the way there, but the deeper
you go the more niche circumstances you may run into. And unfortunately,
there is no proper specification to refer to.
The good news is that you can override the lifetime elision behavior by
being explicit about the lifetime, which provides an escape hatch from
most of the complexity. So when in doubt, be explicit!
In the following subsections, we present the current behavior of the compiler
in layers, to the extent we have explored them.
We occasionally refer to [the reference's documentation on trait object lifetime elision](https://doc.rust-lang.org/reference/lifetime-elision.html#default-trait-object-lifetimes).
However, our layered approach differs somewhat from the reference's approach,
as the reference is not completely accurate.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Keep at it and participate in the community
Experience plays a very big role in undestanding borrow errors and being able
to figure out why some code is problematic in a reasonable amount of time.
Running into borrow check errors and solving them, either on your own or by
asking for help, is a part of the process of building up that intuition.
I personally learned a great deal by participating on the
[Rust user's forum, URLO.](https://users.rust-lang.org/) Another way you can
build experience and broaden your intuition is by reading other's lifetime
questions on that forum, reading the replies to those questions, and trying
to solve their problems -- or even just experiment with them! -- yourself.
By being an active participant, you can not only learn more, but will eventually
be able to help out other users.
* When you read a question and are lost: read the replies and see if you can understand them and learn more
* When you have played with a question and got it to comple but aren't sure why: reply with something like
"I don't know if this fixes your use case, but this compiles for me: [Playground](https://play.rust-lang.org/)"
* After you've got the hang of certain common problems: "It's because of XYZ. You can do this instead: ..."
Even after I got my sea-legs, some of the more advanced lifetime and borrow-checker skills
I've developed came from solving other people's problems on this forum. Once you can answer
their questions, you may still learn things if someone else comes along and provides a
different or better solution.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Lifetime bounds
Here's a brief introduction to the lifetime bounds you may see on `fn` declarations and `impl` blocks.
## Bounds between lifetimes
A `'a: 'b` bound means, roughly speaking, `'long: 'short`.
It's often read as "`'a` outlives `'b`" and it sometimes called an "outlives bound" or "outlives relation".
I personally also like to read it as "`'a` is valid for (at least) `'b`".
Note that `'a` may be the same as `'b`, it does not have to be strictly longer despite the "outlives"
terminology. It is analogous to `>=` in this respect. Therefore, in this example:
```rust
fn example<'a: 'b, 'b: 'a>(a: &'a str, b: &'b str) {}
```
`'a` and `'b` must actually be the same lifetime.
When you have a function argument with a nested reference such as `&'b Foo<'a>`, a `'a: 'b` bound is inferred.
## Bounds between (generic) types and lifetimes
A `T: 'a` means that a `&'a T` would not be instantly undefined behavior. In other words, it
means that if the type `T` contains any references or other lifetimes, they must be at least
as long as `'a`.
You can also read these as "(the type) `T` is valid for `'a`".
Note that this has nothing to do with the liveness scope or drop scope of a *value* of type `T`!
In particular the most common bound of this form is `T: 'static`.
This does not mean the value of type `T` must last for your entire program! It just means that
the type `T` has no non-`'static` lifetimes. `String: 'static` for example, but this doesn't
mean that you don't drop `String`s.
## Liveness scopes of values
For the above reasons, I prefer to never refer to the liveness or drop scope of a value as
the value's "lifetime". Although there is a connection between the liveness scope of values
and lifetimes of references you take to it, conflating the two concepts can lead to confusion.
That said, not everyone follows this convention, so you may see the liveness scope of a value
refered to as the values "lifetime". So the distinction is something to just generally be
aware of.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Combining traits
Rust has no support for directly combining multiple non-auto traits
into one `dyn Trait1 + Trait2`:
```rust,compile_fail
trait Foo { fn foo(&self) {} }
trait Bar { fn bar(&self) {} }
// Fails
let _: Box<dyn Foo + Bar> = todo!();
```
However, the methods of a supertrait are available to the subtrait.
What's a supertrait? A supertrait is a trait bound on `Self` in the
definition of the subtrait, like so:
```rust
# trait Foo { fn foo(&self) {} }
# trait Bar { fn bar(&self) {} }
trait Subtrait: Foo
// ^^^^^^^^^^^^^ A supertrait bound
where
Self: Bar,
// ^^^^^^^^^ Another one
{}
```
The supertrait bound is implied everywhere the subtrait bound is
present, and the methods of the supertrait are always available on
implementors of the subtrait.
Using these relationships, you can support something analogous to
`dyn Foo + Bar` by using `dyn Subtrait`.
```rust
# trait Foo { fn foo(&self) {} }
# trait Bar { fn bar(&self) {} }
# impl Foo for () {}
# impl Bar for () {}
trait Subtrait: Foo + Bar {}
// Blanket implement for everything that meets the bounds...
// ...including non-`Sized` types
impl<T: ?Sized> Subtrait for T where T: Foo + Bar {}
fn main() {
let quz: &dyn Subtrait = &();
quz.foo();
quz.bar();
}
```
Note that despite the terminology, there is no sub/super *type* relationship
between sub/super traits, between `dyn SubTrait` and `dyn SuperTrait`,
between implementors of said traits, et cetera.
[Traits are not about sub/super typing.](./dyn-trait-overview.md#dyn-trait-is-not-a-supertype)
## Manual supertrait upcasting
[Supertrait upcasting is planned, but not yet stable.](./dyn-trait-coercions.md#supertrait-upcasting)
Until stabilized, if you need to cast something like `dyn Subtrait` to `dyn Foo`, you
have to supply the implementation yourself.
For a start, we could build it into our traits like so:
```rust
trait Foo {
fn foo(&self) {}
fn as_dyn_foo(&self) -> &dyn Foo;
}
```
But we can't supply a default function body, as `Self: Sized` is required to perform
the type erasing cast to `dyn Foo`. We don't want that restriction or the method
won't be available on `dyn Supertrait`, which is not `Sized`.
Instead we can separate out the method and supply an implementation for all `Sized`
types, via another supertrait:
```rust
trait AsDynFoo {
fn as_dyn_foo(&self) -> &dyn Foo;
}
trait Foo: AsDynFoo { fn foo(&self) {} }
```
And then supply the implementation for all `Sized + Foo` types:
```rust
# trait AsDynFoo { fn as_dyn_foo(&self) -> &dyn Foo; }
# trait Foo: AsDynFoo { fn foo(&self) {} }
impl<T: /* Sized + */ Foo> AsDynFoo for T {
fn as_dyn_foo(&self) -> &dyn Foo {
self
}
}
```
The compiler will supply the implementation for both `dyn AsDynFoo` and `dyn Foo`.
When we put this altogether with the `Subtrait` from above, we can now utilize
an explicit version of supertrait upcasting:
```rust
trait Foo: AsDynFoo { fn foo(&self) {} }
trait Bar: AsDynBar { fn bar(&self) {} }
impl Foo for () {}
impl Bar for () {}
trait AsDynFoo { fn as_dyn_foo(&self) -> &dyn Foo; }
trait AsDynBar { fn as_dyn_bar(&self) -> &dyn Bar; }
impl<T: Foo> AsDynFoo for T { fn as_dyn_foo(&self) -> &dyn Foo { self } }
impl<T: Bar> AsDynBar for T { fn as_dyn_bar(&self) -> &dyn Bar { self } }
trait Subtrait: Foo + Bar {}
impl<T: ?Sized> Subtrait for T where T: Foo + Bar {}
fn main() {
let quz: &dyn Subtrait = &();
quz.foo();
quz.bar();
let _: &dyn Foo = quz.as_dyn_foo();
let _: &dyn Bar = quz.as_dyn_bar();
}
```
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# `dyn Trait` lifetimes and `Box<dyn Trait>`
Every trait object (`dyn Trait`) has an elide-able lifetime with it's own defaults when completely elided.
This default is stronger than the normal function signature elision rules.
The most common way to run into a lifetime error about this is with `Box<dyn Trait>` in your function signatures, structs, and type aliases, where it means `Box<dyn Trait + 'static>`.
Often the error indicates that non-`'static` references/types aren't allowed in that context,
but sometimes it means that you should add an explicit lifetime, like `Box<dyn Trait + 'a>` or `Box<dyn Trait + '_>`.
The latter will act like "normal" lifetime elision; for example, it will introduce a new anonymous lifetime
parameter as a function input parameter, or use the `&self` lifetime in return position.
The reason the lifetime exists is that coercing values to `dyn Trait` erases their base type, including any
lifetimes that it may contain. But those lifetimes have to be tracked by the compiler somehow to ensure
memory safety. The `dyn Trait` lifetime represents the maximum lifetime the erased type is valid for.
---
Some short examples:
```rust
trait Trait {}
// The return is `Box<dyn Trait + 'static>` and this errors as there
// needs to be a bound requiring `T` to be `'static`, or the return
// type needs to be more flexible
fn one<T: Trait>(t: T) -> Box<dyn Trait> {
Box::new(t)
}
// This works as we've added the bound
fn two<T: Trait + 'static>(t: T) -> Box<dyn Trait> {
Box::new(t)
}
// This works as we've made the return type more flexible. We still
// have to add a lifetime bound.
fn three<'a, T: Trait + 'a>(t: T) -> Box<dyn Trait + 'a> {
Box::new(t)
}
```
For a more in-depth exploration,
[see this section of the `dyn Trait` tour.](./dyn-elision.md)
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Copy and reborrows
Shared references (`&T`) implement `Copy`, which makes them very flexible. Once you have one,
you can have as many as you want; once you've exposed one, you can't keep track of how many there are.
Exclusive references (`&mut T`) do not implement `Copy`.
Instead, you can use them ergonomically through a mechanism called *reborrowing*. For example here:
```rust
fn foo<'v>(v: &'v mut Vec<i32>) {
v.push(0); // line 1
println!("{v:?}"); // line 2
}
```
You're not moving `v: &mut Vec<i32>` when you pass it to `push` on line 1, or you couldn't print it on line 2.
But you're not copying it either, because `&mut _` does not implement `Copy`.
Instead `*v` is reborrowed for some shorter lifetime than `'v`, which ends on line 1.
An explicit reborrow would look like this:
```rust,no_compile
Vec::push(&mut *v, 0);
```
`v` can't be used while the reborrow `&mut *v` exists, but after it "expires", you can use `v` again.
Though tragically underdocumented, reborrowing is what makes `&mut` usable; there's a lot of implicit reborrowing in Rust.
Reborrowing makes `&mut T` act like the `Copy`-able `&T` in some ways. But the necessity that `&mut T` is exclusive while
it exists leads to it being much less flexible.
Reborrowing is a large topic on its own, but you should at least understand that it exists, and is what enables Rust to
be usable and ergonomic while still enforcing memory safety.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
{{#title Learning Rust}}
# Learning Rust
Welcome to my collection of resources for those learning the
[Rust programming language.](https://www.rust-lang.org/) The advice in
these pages is typically suitable for those with at least a beginning
familiarity of Rust -- for example, those who have worked through
[The Book](https://doc.rust-lang.org/book/) -- but are still experiencing
the growing pains of learning Rust.
## [Practical suggestions for building intuition around borrow errors](lifetime-intuition.md)
In this section we outline the basics of understanding lifetimes and borrowing for
those who are struggling with understanding borrow check errors.
## [A tour of `dyn Trait`](./dyn-trait.md)
In this section we explore what `dyn Trait` is and is not, go over its limitations
and strengths, deep dive on how lifetimes work with `dyn Trait`, provide some
common `dyn Trait` recipes, and more.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Advice to change function signature when aliases are involved
[Here's a scenario from earlier in this guide.](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=ad6f395f748927ae66d06b2fd42603ea) The compiler advice is:
```rust
error[E0621]: explicit lifetime required in the type of `s`
--> src/lib.rs:5:9
|
4 | fn new(s: &str) -> Node<'_> {
| ---- help: add explicit lifetime `'a` to the type of `s`: `&'a str`
5 | Self(s)
| ^^^^^^^ lifetime `'a` required
```
But [this works just as well:](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=9d89786c76424d66e7eb11ca7716645b)
```diff
- Self(s)
+ Node(s)
```
And you may get this advice when implementing a trait, where you usually *can't* change the signature.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# `dyn Trait` implementations
In order for `dyn Trait` to be useful for abstracting over the base
types which implement `Trait`, `dyn Trait` itself needs to implement
`Trait`. The compiler always supplies that implementation. Here we
look at how this notionally works, and also touch on how this leads
to some related limitations around `dyn Trait`.
We also cover a few surprising corner-cases related to how the
implementation of `Trait` for `dyn Trait` works... or doesn't.
## How `dyn Trait` implements `Trait`
Let us note upfront: this is a rough sketch, and not normative. What the
compiler actually does is an implementation detail. But by providing a
sketch of how it *could* be implemented, we hope to provide some intuition
for `dyn Trait` being a concrete type, and some explanation of the
limitations that `dyn Trait` has.
With that disclaimer out of the way, let's look at what the compiler
implementation might look like for this trait:
```rust
trait Trait {
fn look(&self);
fn add(&mut self, s: String) -> i32;
}
```
Recall that when dealing with `dyn Trait`, you'll be dealing with
a pointer to the erased base type, and with a vtable. For example,
we could imagine a `&dyn Trait` looks something like this:
```rust,ignore
#[repr(C)]
struct DynTraitRef<'a> {
_lifetime: PhantomData<&'a ()>,
base_type: *const (),
vtable: &'static DynTraitVtable,
}
// Pseudo-code
type &'a dyn Trait = DynTraitRef<'a>;
```
Here we're using a thin `*const ()` to point to the erased base type.
Similarly, you can imagine a `DynTraitMut<'a>` for `&'a mut dyn Trait`
that uses `*mut ()`.
And the vtable might look something like this:
```rust
#[repr(C)]
struct DynTraitVtable {
fn_drop: fn(*mut ()),
type_size: usize,
type_alignment: usize,
fn_look: fn(*const ()),
fn_add: fn(*mut (), s: String) -> i32,
}
```
And the implementation itself could look something like this:
```rust,ignore
impl Trait for dyn Trait + '_ {
fn look(&self) {
(self.vtable.fn_look)(self.base_type)
}
fn add(&mut self, s: String) -> i32 {
(self.vtable.fn_add)(self.base_type, s)
}
}
```
In summary, we've erased the base type by replacing references to the
base type with the appropriate type of pointer to the same data, both
in the wide references (`&dyn Trait`, `&mut dyn Trait`), and also in
the vtable function pointers. The compiler guarantees there's no ABI
mismatch.
*Reminder:* This is just a rough sketch on how `dyn Trait` can be
implemented to aid the high-level understanding and discussion, and
not necessary exactly how they *are* implemented.
[Here's another blog post on the topic.](https://huonw.github.io/blog/2015/01/peeking-inside-trait-objects/)
Note that it was written in 2015, and some things in Rust have changed
since that time. For example, [trait objects used to be "spelled" just
`Trait` instead of `dyn Trait`.](https://rust-lang.github.io/rfcs/2113-dyn-trait-syntax.html)
You'll have to figure out if they're talking about the trait or the
`dyn Trait` type from context.
## Other receivers
Let's look at one other function signature:
```rust
trait Trait {
fn eat_box(self: Box<Self>);
}
```
How does this work? Internally, a `Box<BaseType /* : Sized */>` is
a thin pointer, while a `Box<dyn Trait>` is wide pointer, very similar
to `&mut dyn Trait` for example (although the `Box` pointer implies ownership and
not just exclusivity). The implementation for this method would be
similar to that of `&mut dyn Trait` as well:
```rust,ignore
// Still just for illustrative purpose
impl Trait for dyn Trait + '_ {
fn eat_box(self: Box<Self>) {
let BoxRepresentation { base_type, vtable } = self;
let boxed_type = Box::from_raw(base_type);
(vtable.fn_eat_box)(boxed_type);
}
}
```
In short, the compiler knows how to go from the type-earased form
(like `Box<Self>`) into something ABI compatible for the base type
(`Box<BaseType>`) for every supported receiver type.
It's an implementation detail, but currently the way the compiler
knows how to do the conversion is via the
[`DispatchFromDyn`](https://doc.rust-lang.org/std/ops/trait.DispatchFromDyn.html)
trait. The documentation lists the current limitations of supported
types (some of which are only available under the unstable
[`arbitrary_self_types` feature](https://github.com/rust-lang/rust/issues/44874)).
## Supertraits are also implemented
[We'll look at supertraits in more detail later,](./dyn-trait-combining.md) but
here we'll briefly note that when you have a supertrait:
```
trait SuperTrait { /* ... */ }
trait Trait: SuperTrait { /* ... */ }
```
The vtable for `dyn Trait` includes the methods of `SuperTrait` and the compiler
supplies an implementation of `SuperTrait` for `dyn Trait`, just as it supplies
an implementation of `Trait`.
## `Box<dyn Trait>` and `&dyn Trait` do not automatically implement `Trait`
It may come as a suprise that neither `Box<dyn Trait>` nor
`&dyn Trait` automatically implement `Trait`. Why not?
In short, because it's not always possible.
[As we'll cover later,](dyn-safety.md#the-sized-constraints) a trait
may have methods which are not dispatchable by `dyn Trait`, but must
be implemented for any `Sized` type. One example is associated
functions that have no receiver:
```rust
trait Trait {
fn no_receiver() -> String where Self: Sized;
}
```
There's no way for the compiler to generate the body of such an associated
function, and it can't provide a complete `Trait` implementation without
one.
Additionally, the receivers of dispatchable methods don't always make
sense:
```rust
trait Trait {
fn takes_mut(&mut self);
}
```
A `&dyn Trait` can produce a `&BaseType`, but not a `&mut BaseType`, so
there is no way to implement `Trait::takes_mut` for `&dyn Trait` when
the only pre-existing implementation is for `BaseType`.
Similarly, an `Arc<dyn Trait>` has no way to call a `Box<dyn Trait>`
or vice-versa, and so on.
### Implementing these yourself
If `Trait` is a local trait, you can implement it for `Box<dyn Trait + '_>`
and so on just like you would for any other type. Take care though, as it
can be easy to accidentally write a recursive definition!
[We walk through an example of this later on.](./dyn-trait-box-impl.md)
Moreover, `&T`, `&mut T`, and `Box<T>` are
[*fundamental*,](https://rust-lang.github.io/rfcs/2451-re-rebalancing-coherence.html#definitions)
which means that when it comes to the orphan rules (which gate which trait
implementations you can write), they act the same as `T`. Additionally,
if `Trait` is a local trait, then `dyn Trait + '_` is a local type.
Together that means that *you can even implement **other** traits* for
`Box<dyn Trait + '_>` (and other fundamental wrappers)!
[We also have an example of this later on.](dyn-trait-clone.md)
Unfortunately, `Rc`, `Arc`, and so on are not fundamental, so this doesn't
cover every possible use case.
## The implementation cannot be directly overrode
The compiler provided implementation of `Trait` for `dyn Trait` cannot be
overrode by an implementation in your code. If you attempt to define your
own definition directly, you'll get a compiler error:
```rust,compile_fail
trait Trait {}
impl Trait for dyn Trait + '_ {}
```
And if you have a blanket implementation to implement `Trait` and `dyn Trait`
happens to meet the bounds on the implementation, it will be ignored and the
compiler defined implementation will still be used:
```rust
#use std::any::type_name;
#
trait Trait {
fn hi(&self) {
println!("Hi from {}!", type_name::<Self>());
}
}
// The simplest example is an implementation for absolutely everything
impl<T: ?Sized> Trait for T {}
let dt: &dyn Trait = &();
// Prints "Hi from ()!" and not "Hi from dyn Trait!"
dt.hi();
// Same thing
<dyn Trait as Trait>::hi(dt);
```
[This applies no matter how complicated the implementations are,](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=66a0de00d42d915134f206ee73291136)
and applies to the supertrait implementations for `dyn Trait` as well.
## The implementation cannot be indirectly bypassed
You may be aware that when a concrete type has an inherent method with
the same name and receiver as a trait method, the inherent method takes
precedence when performing method lookup:
```rust
trait Trait { fn method(&self) { println!("In trait Trait"); } }
struct S;
impl Trait for S {}
impl S { fn method(&self) { println!("In impl S"); } }
fn main() {
let s = S;
s.method();
// If you wanted to use the trait, you can do this
<S as Trait>::method(&s);
}
```
Unfortunately, this functionality is not available for `dyn Trait`.
You can write the implementation, but unlike the example above, they
will be considered ambiguous with the trait methods:
```rust,compile_fail
trait Trait {
fn method(&self) {}
fn non_dyn_dispatchable(&self) where Self: Sized {}
}
impl dyn Trait + '_ {
fn method(&self) {}
fn non_dyn_dispatchable(&self) {}
}
fn foo(d: &dyn Trait) {
d.method();
d.non_dyn_dispatchable();
}
```
Moreover, there is no syntax to call the inherent methods specifically
like there is for normal `struct`s.
[Even if you try to hide the trait,](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=6f55d2ebb8b44349034fc4df120e152f)
the inherent methods are unreachable, dead code.
Apparently the idea is that the trait methods "are" the inherent methods of
`dyn Trait`, but this is rather unfortunate as it prevents directly providing
something like the `non_dyn_dispatchable` override attempted above.
See [issue 51402](https://github.com/rust-lang/rust/issues/51402) for more
information.
Implementing methods on `dyn Trait` that don't attempt to shadow the
methods of `Trait` does work, however.
```rust
#trait Trait {}
impl dyn Trait + '_ {
fn some_other_method(&self) {}
}
fn bar(d: &dyn Trait) {
d.some_other_method();
}
```
## A niche exception to `dyn Trait: Trait`
Some bounds on traits aren't checked until you try to utilize the trait,
even when the trait is considered object safe. As a result, [it is
actually sometimes possible to create a `dyn Trait` that does not implement
`Trait`!](https://github.com/rust-lang/rust/issues/88904)
```rust,compile_fail
trait Iterable
where
for<'a> &'a Self: IntoIterator<
Item = &'a <Self as Iterable>::Borrow,
>,
{
type Borrow;
fn iter(&self) -> Box<dyn Iterator<Item = &Self::Borrow> + '_> {
Box::new(self.into_iter())
}
}
impl<I: ?Sized, Borrow> Iterable for I
where
for<'a> &'a Self: IntoIterator<Item = &'a Borrow>,
{
type Borrow = Borrow;
}
fn example(v: Vec<String>) {
// This compiles, demonstrating that we can create `dyn Iterable`
// (i.e. the trait is object safe and `v` can be coerced)
let dt: &dyn Iterable<Borrow = String> = &v;
// But this gives an error as `&dyn Iterable` doesn't meet the trait
// bound, and thus `dyn Iterable` does not implement `Iterable`!
for item in dt.iter() {
println!("{item}");
}
}
```
With this particular example, [it's possible to provide an implementation such that
`dyn Iterable` meets the bounds.](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=7b897bcb453c6d8b7b8e3461f70db7a6)
If that's not possible, you probably need to drop the bound or give up
on the trait being `dyn`-safe.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Don't hide lifetimes
When you use lifetime-carrying structs (whether your own or someone else's),
the Rust compiler currently let's you elide the lifetime parameter when
mentioning the struct:
```rust
struct Foo<'a>(&'a str);
impl<'a> Foo<'a> {
// No lifetime syntax needed :-(
// vvv
fn new(s: &str) -> Foo {
Foo(s)
}
}
```
This can make it non-obvious that borrowing is going on, and harder to figure
out where errors are coming from. To save yourself some headaches, I recommend
using the `#![deny(elided_lifetimes_in_paths)]` lint:
```rust,compile_fail
#![deny(elided_lifetimes_in_paths)]
struct Foo<'a>(&'a str);
impl<'a> Foo<'a> {
// Now this is an error
// vvv
fn new(s: &str) -> Foo {
Foo(s)
}
}
```
The first thing I do when taking on a borrow check error in someone else's code
is to turn on this lint. If you have not enabled the lint and are getting errors
in your own code, try enabling the lint. For every place that errors, take a moment
to pause and consider what is going on with the lifetimes. Sometimes there's only
one possibility and you will just need to make a trivial change:
```diff
- fn new(s: &str) -> Foo {
+ fn new(s: &str) -> Foo<'_> {
```
But often, in my experience, one of the error sites will be part of the problem
you're dealing with.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
# Conditional return of a borrow
The compiler isn't perfect, and there are some things it doesn't yet accept which are in fact sound and could be accepted.
Perhaps the most common one to trip on is [conditional return of a borrow,](https://github.com/rust-lang/rust/issues/51545) aka NLL Problem Case #3.
There are some examples and workarounds in the issue and related issues.
The plan is still to accept that pattern some day.
More generally, if you run into something and don't understand why it's an error or think it should be allowed, try asking in a forum post.
| {
"repo_name": "QuineDot/rust-learning",
"stars": "41",
"repo_language": "None",
"file_name": "pf-nll3.md",
"mime_type": "text/plain"
} |
<!--
Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
This code is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License version 2 only, as
published by the Free Software Foundation. Oracle designates this
particular file as subject to the "Classpath" exception as provided
by Oracle in the LICENSE file that accompanied this code.
This code is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
version 2 for more details (a copy is included in the LICENSE file that
accompanied this code).
You should have received a copy of the GNU General Public License version
2 along with this work; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
or visit www.oracle.com if you need additional information or have any
questions.
-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>info.java-performance</groupId>
<artifactId>maptest</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
<name>Auto-generated JMH benchmark</name>
<prerequisites>
<maven>3.0</maven>
</prerequisites>
<dependencies>
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-core</artifactId>
<version>${jmh.version}</version>
</dependency>
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-generator-annprocess</artifactId>
<version>${jmh.version}</version>
<scope>provided</scope>
</dependency>
<!-- Fastutil -->
<dependency>
<groupId>it.unimi.dsi</groupId>
<artifactId>fastutil</artifactId>
<version>8.5.2</version>
</dependency>
<!-- Trove -->
<dependency>
<groupId>net.sf.trove4j</groupId>
<artifactId>trove4j</artifactId>
<version>3.0.3</version>
</dependency>
<!-- Koloboke -->
<dependency>
<groupId>com.koloboke</groupId>
<artifactId>koloboke-api-jdk8</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>com.koloboke</groupId>
<artifactId>koloboke-impl-jdk8</artifactId>
<version>1.0.0</version>
<scope>runtime</scope>
</dependency>
<!-- Goldman Sachs, now Eclipse, collections -->
<dependency>
<groupId>org.eclipse.collections</groupId>
<artifactId>eclipse-collections</artifactId>
<version>11.0.0.M1</version>
</dependency>
<!-- HPPC -->
<dependency>
<groupId>com.carrotsearch</groupId>
<artifactId>hppc</artifactId>
<version>0.9.0.RC2</version>
</dependency>
<!-- Agrona -->
<dependency>
<groupId>org.agrona</groupId>
<artifactId>agrona</artifactId>
<version>1.9.0</version>
</dependency>
<!-- JUnit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.1</version>
<scope>test</scope>
</dependency>
</dependencies>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<jmh.version>1.27</jmh.version>
<javac.target>1.8</javac.target>
<uberjar.name>benchmarks</uberjar.name>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<compilerVersion>${javac.target}</compilerVersion>
<source>${javac.target}</source>
<target>${javac.target}</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.2.4</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<finalName>${uberjar.name}</finalName>
<transformers>
<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<mainClass>org.openjdk.jmh.Main</mainClass>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
<pluginManagement>
<plugins>
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>3.1.0</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.8.2</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.2</version>
</plugin>
<plugin>
<artifactId>maven-jar-plugin</artifactId>
<version>3.2.0</version>
</plugin>
<plugin>
<artifactId>maven-javadoc-plugin</artifactId>
<version>3.2.0</version>
</plugin>
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.2.0</version>
</plugin>
<plugin>
<artifactId>maven-site-plugin</artifactId>
<version>3.9.1</version>
</plugin>
<plugin>
<artifactId>maven-source-plugin</artifactId>
<version>3.2.1</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.22.2</version>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>
| {
"repo_name": "mikvor/hashmapTest",
"stars": "94",
"repo_language": "Java",
"file_name": "BaseIntIntMapTest.java",
"mime_type": "text/x-java"
} |
# hashmapTest
HashMap performance tests from java-performance.info
| {
"repo_name": "mikvor/hashmapTest",
"stars": "94",
"repo_language": "Java",
"file_name": "BaseIntIntMapTest.java",
"mime_type": "text/x-java"
} |
package map.objobj;
import junit.framework.TestCase;
import tests.MapTestRunner;
import tests.maptests.IMapTest;
import tests.maptests.article_examples.ObjObjMapTest;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ThreadLocalRandom;
public class ObjObjMapUnitTest extends TestCase {
private ObjObjMap<Integer, Integer> makeMap( final int size, final float fillFactor )
{
return new ObjObjMap<>( size, fillFactor );
}
public void testPut()
{
final ObjObjMap<Integer, Integer> map = makeMap(100, 0.5f);
for ( int i = 0; i < 100000; ++i )
{
map.put(i, i);
assertEquals(i + 1, map.size());
assertEquals(Integer.valueOf(i), map.get( i ));
}
//now check the final state
for ( int i = 0; i < 100000; ++i )
assertEquals(Integer.valueOf(i), map.get( i ));
}
public void testPutNegative()
{
final ObjObjMap<Integer, Integer> map = makeMap(100, 0.5f);
for ( int i = 0; i < 100000; ++i )
{
map.put(-i, -i);
assertEquals(i + 1, map.size());
assertEquals(Integer.valueOf(-i), map.get( -i ));
}
//now check the final state
for ( int i = 0; i < 100000; ++i )
assertEquals(Integer.valueOf(-i), map.get( -i ));
}
public void testPutRandom()
{
final int SIZE = 100 * 1000;
final Set<Integer> set = new HashSet<>( SIZE );
final int[] vals = new int[ SIZE ];
while ( set.size() < SIZE )
set.add( ThreadLocalRandom.current().nextInt() );
int i = 0;
for ( final Integer v : set )
vals[ i++ ] = v;
final ObjObjMap<Integer, Integer> map = makeMap(100, 0.5f);
for ( i = 0; i < vals.length; ++i )
{
map.put(vals[ i ], vals[ i ]);
assertEquals(i + 1, map.size());
assertEquals(Integer.valueOf( vals[ i ] ), map.get( vals[ i ] ));
}
//now check the final state
for ( i = 0; i < vals.length; ++i )
assertEquals(Integer.valueOf( vals[ i ] ), map.get( vals[ i ] ));
}
public void testRemove()
{
final ObjObjMap<Integer, Integer> map = makeMap(100, 0.5f);
int addCnt = 0, removeCnt = 0;
for ( int i = 0; i < 100000; ++i )
{
assertNull(map.put(addCnt, addCnt));
addCnt++;
assertNull(map.put(addCnt, addCnt));
addCnt++;
assertEquals(Integer.valueOf(removeCnt), map.remove(removeCnt));
removeCnt++;
assertEquals(i + 1, map.size()); //map grows by one element on each iteration
}
for ( int i = removeCnt; i < addCnt; ++i )
assertEquals(Integer.valueOf(i), map.get( i ));
}
public void test1()
{
final ObjObjMapTest test = new ObjObjMapTest();
final IMapTest test1 = test.getTest();
final int[] keys = MapTestRunner.KeyGenerator.getKeys( 10000 );
test1.setup( keys, 0.5f, 2 );
test1.test();
}
public void test2()
{
final ObjObjMapTest test = new ObjObjMapTest();
final IMapTest test1 = test.putTest();
final int[] keys = MapTestRunner.KeyGenerator.getKeys( 10 * 1000 );
test1.setup( keys, 0.5f, 2 );
test1.test();
}
public void test3()
{
final ObjObjMapTest test = new ObjObjMapTest();
final IMapTest test1 = test.removeTest();
final int[] keys = MapTestRunner.KeyGenerator.getKeys( 10000 );
test1.setup( keys, 0.5f, 2 );
test1.test();
}
}
| {
"repo_name": "mikvor/hashmapTest",
"stars": "94",
"repo_language": "Java",
"file_name": "BaseIntIntMapTest.java",
"mime_type": "text/x-java"
} |
package map.intint;
public class IntIntMap4aUnitTest extends BaseIntIntMapUnitTest {
@Override
protected IntIntMap makeMap(int size, float fillFactor) {
return new IntIntMap4a(size, fillFactor);
}
}
| {
"repo_name": "mikvor/hashmapTest",
"stars": "94",
"repo_language": "Java",
"file_name": "BaseIntIntMapTest.java",
"mime_type": "text/x-java"
} |
package map.intint;
public class IntIntMap1UnitTest extends BaseIntIntMapUnitTest {
@Override
protected IntIntMap makeMap(int size, float fillFactor) {
return new IntIntMap1( size, fillFactor );
}
}
| {
"repo_name": "mikvor/hashmapTest",
"stars": "94",
"repo_language": "Java",
"file_name": "BaseIntIntMapTest.java",
"mime_type": "text/x-java"
} |
package map.intint;
import junit.framework.TestCase;
import tests.MapTestRunner;
import tests.maptests.IMapTest;
import tests.maptests.article_examples.BaseIntIntMapTest;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ThreadLocalRandom;
public abstract class BaseIntIntMapUnitTest extends TestCase {
private final static float[] FILL_FACTORS = { 0.25f, 0.5f, 0.75f, 0.9f, 0.99f };
abstract protected IntIntMap makeMap( final int size, final float fillFactor );
public void testPut()
{
for ( final float ff : FILL_FACTORS )
testPutHelper( ff );
}
private void testPutHelper( final float fillFactor )
{
final IntIntMap map = makeMap(100, fillFactor);
for ( int i = 0; i < 100000; ++i )
{
assertEquals(0, map.put(i, i) );
assertEquals(i + 1, map.size());
assertEquals(i, map.get( i ));
}
//now check the final state
for ( int i = 0; i < 100000; ++i )
assertEquals(i, map.get( i ));
}
public void testPutNegative()
{
for ( final float ff : FILL_FACTORS )
testPutNegative( ff );
}
private void testPutNegative( final float fillFactor )
{
final IntIntMap map = makeMap(100, fillFactor);
for ( int i = 0; i < 100000; ++i )
{
map.put(-i, -i);
assertEquals(i + 1, map.size());
assertEquals(-i, map.get( -i ));
}
//now check the final state
for ( int i = 0; i < 100000; ++i )
assertEquals(-i, map.get( -i ));
}
public void testPutRandom()
{
for ( final float ff : FILL_FACTORS )
testPutRandom( ff );
}
private void testPutRandom( final float fillFactor )
{
final int SIZE = 100 * 1000;
final Set<Integer> set = new HashSet<>( SIZE );
final int[] vals = new int[ SIZE ];
while ( set.size() < SIZE )
set.add( ThreadLocalRandom.current().nextInt() );
int i = 0;
for ( final Integer v : set )
vals[ i++ ] = v;
final IntIntMap map = makeMap(100, fillFactor);
for ( i = 0; i < vals.length; ++i )
{
assertEquals(0, map.put(vals[ i ], vals[ i ]) );
assertEquals(i + 1, map.size());
assertEquals(vals[ i ], map.get( vals[ i ] ));
}
//now check the final state
for ( i = 0; i < vals.length; ++i )
assertEquals(vals[ i ], map.get( vals[ i ] ));
}
public void testRemove()
{
for ( final float ff : FILL_FACTORS )
testRemoveHelper( ff );
}
private void testRemoveHelper( final float fillFactor)
{
final IntIntMap map = makeMap(100, fillFactor);
int addCnt = 0, removeCnt = 0;
for ( int i = 0; i < 100000; ++i )
{
assertEquals(0, map.put(addCnt, addCnt));
addCnt++;
assertEquals( "Failed for addCnt = " + addCnt + ", ff = " + fillFactor, 0, map.put(addCnt, addCnt));
addCnt++;
assertEquals(removeCnt, map.remove(removeCnt));
removeCnt++;
assertEquals(i + 1, map.size()); //map grows by one element on each iteration
}
for ( int i = removeCnt; i < addCnt; ++i )
assertEquals(i, map.get( i ));
}
public void test1()
{
final BaseIntIntMapTest test = new BaseIntIntMapTest() {
@Override
public IntIntMap makeMap(int size, float fillFactor) {
return BaseIntIntMapUnitTest.this.makeMap(size, fillFactor);
}
};
for ( final float ff : FILL_FACTORS )
testNHelper( ff, test.getTest() );
}
public void test2()
{
final BaseIntIntMapTest test = new BaseIntIntMapTest() {
@Override
public IntIntMap makeMap(int size, float fillFactor) {
return BaseIntIntMapUnitTest.this.makeMap(size, fillFactor);
}
};
for ( final float ff : FILL_FACTORS )
testNHelper( ff, test.putTest() );
}
public void test3()
{
final BaseIntIntMapTest test = new BaseIntIntMapTest() {
@Override
public IntIntMap makeMap(int size, float fillFactor) {
return BaseIntIntMapUnitTest.this.makeMap(size, fillFactor);
}
};
for ( final float ff : FILL_FACTORS )
testNHelper( ff, test.removeTest() );
}
private void testNHelper( final float fillFactor, final IMapTest test1 )
{
final int[] keys = MapTestRunner.KeyGenerator.getKeys( 10000 );
test1.setup( keys, fillFactor, 2 );
test1.test();
}
}
| {
"repo_name": "mikvor/hashmapTest",
"stars": "94",
"repo_language": "Java",
"file_name": "BaseIntIntMapTest.java",
"mime_type": "text/x-java"
} |
package map.intint;
public class IntIntMap2UnitTest extends BaseIntIntMapUnitTest {
@Override
protected IntIntMap makeMap(int size, float fillFactor) {
return new IntIntMap2(size, fillFactor);
}
}
| {
"repo_name": "mikvor/hashmapTest",
"stars": "94",
"repo_language": "Java",
"file_name": "BaseIntIntMapTest.java",
"mime_type": "text/x-java"
} |
package map.intint;
public class IntIntMap4UnitTest extends BaseIntIntMapUnitTest {
@Override
protected IntIntMap makeMap(int size, float fillFactor) {
return new IntIntMap4( size, fillFactor );
}
}
| {
"repo_name": "mikvor/hashmapTest",
"stars": "94",
"repo_language": "Java",
"file_name": "BaseIntIntMapTest.java",
"mime_type": "text/x-java"
} |
package map.intint;
public class IntIntMap3UnitTest extends BaseIntIntMapUnitTest {
@Override
protected IntIntMap makeMap(int size, float fillFactor) {
return new IntIntMap3( size, fillFactor );
}
}
| {
"repo_name": "mikvor/hashmapTest",
"stars": "94",
"repo_language": "Java",
"file_name": "BaseIntIntMapTest.java",
"mime_type": "text/x-java"
} |
package map.objobj;
import map.intint.Tools;
import java.util.Arrays;
/**
* Object-2-object map based on IntIntMap4a
*/
public class ObjObjMap<K, V>
{
private static final Object FREE_KEY = new Object();
private static final Object REMOVED_KEY = new Object();
/** Keys and values */
private Object[] m_data;
/** Value for the null key (if inserted into a map) */
private Object m_nullValue;
private boolean m_hasNull;
/** Fill factor, must be between (0 and 1) */
private final float m_fillFactor;
/** We will resize a map once it reaches this size */
private int m_threshold;
/** Current map size */
private int m_size;
/** Mask to calculate the original position */
private int m_mask;
/** Mask to wrap the actual array pointer */
private int m_mask2;
public ObjObjMap( final int size, final float fillFactor )
{
if ( fillFactor <= 0 || fillFactor >= 1 )
throw new IllegalArgumentException( "FillFactor must be in (0, 1)" );
if ( size <= 0 )
throw new IllegalArgumentException( "Size must be positive!" );
final int capacity = Tools.arraySize(size, fillFactor);
m_mask = capacity - 1;
m_mask2 = capacity * 2 - 1;
m_fillFactor = fillFactor;
m_data = new Object[capacity * 2];
Arrays.fill( m_data, FREE_KEY );
m_threshold = (int) (capacity * fillFactor);
}
public V get( final K key )
{
if ( key == null )
return (V) m_nullValue; //we null it on remove, so safe not to check a flag here
int ptr = (key.hashCode() & m_mask) << 1;
Object k = m_data[ ptr ];
if ( k == FREE_KEY )
return null; //end of chain already
if ( k.equals( key ) ) //we check FREE and REMOVED prior to this call
return (V) m_data[ ptr + 1 ];
while ( true )
{
ptr = (ptr + 2) & m_mask2; //that's next index
k = m_data[ ptr ];
if ( k == FREE_KEY )
return null;
if ( k.equals( key ) )
return (V) m_data[ ptr + 1 ];
}
}
public V put( final K key, final V value )
{
if ( key == null )
return insertNullKey(value);
int ptr = getStartIndex(key) << 1;
Object k = m_data[ptr];
if ( k == FREE_KEY ) //end of chain already
{
m_data[ ptr ] = key;
m_data[ ptr + 1 ] = value;
if ( m_size >= m_threshold )
rehash( m_data.length * 2 ); //size is set inside
else
++m_size;
return null;
}
else if ( k.equals( key ) ) //we check FREE and REMOVED prior to this call
{
final Object ret = m_data[ ptr + 1 ];
m_data[ ptr + 1 ] = value;
return (V) ret;
}
int firstRemoved = -1;
if ( k == REMOVED_KEY )
firstRemoved = ptr; //we may find a key later
while ( true )
{
ptr = ( ptr + 2 ) & m_mask2; //that's next index calculation
k = m_data[ ptr ];
if ( k == FREE_KEY )
{
if ( firstRemoved != -1 )
ptr = firstRemoved;
m_data[ ptr ] = key;
m_data[ ptr + 1 ] = value;
if ( m_size >= m_threshold )
rehash( m_data.length * 2 ); //size is set inside
else
++m_size;
return null;
}
else if ( k.equals( key ) )
{
final Object ret = m_data[ ptr + 1 ];
m_data[ ptr + 1 ] = value;
return (V) ret;
}
else if ( k == REMOVED_KEY )
{
if ( firstRemoved == -1 )
firstRemoved = ptr;
}
}
}
public V remove( final K key )
{
if ( key == null )
return removeNullKey();
int ptr = getStartIndex(key) << 1;
Object k = m_data[ ptr ];
if ( k == FREE_KEY )
return null; //end of chain already
else if ( k.equals( key ) ) //we check FREE and REMOVED prior to this call
{
--m_size;
if ( m_data[ ( ptr + 2 ) & m_mask2 ] == FREE_KEY )
m_data[ ptr ] = FREE_KEY;
else
m_data[ ptr ] = REMOVED_KEY;
final V ret = (V) m_data[ ptr + 1 ];
m_data[ ptr + 1 ] = null;
return ret;
}
while ( true )
{
ptr = ( ptr + 2 ) & m_mask2; //that's next index calculation
k = m_data[ ptr ];
if ( k == FREE_KEY )
return null;
else if ( k.equals( key ) )
{
--m_size;
if ( m_data[ ( ptr + 2 ) & m_mask2 ] == FREE_KEY )
m_data[ ptr ] = FREE_KEY;
else
m_data[ ptr ] = REMOVED_KEY;
final V ret = (V) m_data[ ptr + 1 ];
m_data[ ptr + 1 ] = null;
return ret;
}
}
}
private V insertNullKey(final V value)
{
if ( m_hasNull )
{
final Object ret = m_nullValue;
m_nullValue = value;
return (V) ret;
}
else
{
m_nullValue = value;
++m_size;
return null;
}
}
private V removeNullKey()
{
if ( m_hasNull )
{
final Object ret = m_nullValue;
m_nullValue = null;
m_hasNull = false;
--m_size;
return (V) ret;
}
else
{
return null;
}
}
public int size()
{
return m_size;
}
private void rehash( final int newCapacity )
{
m_threshold = (int) (newCapacity/2 * m_fillFactor);
m_mask = newCapacity/2 - 1;
m_mask2 = newCapacity - 1;
final int oldCapacity = m_data.length;
final Object[] oldData = m_data;
m_data = new Object[ newCapacity ];
Arrays.fill( m_data, FREE_KEY );
m_size = m_hasNull ? 1 : 0;
for ( int i = 0; i < oldCapacity; i += 2 ) {
final Object oldKey = oldData[ i ];
if( oldKey != FREE_KEY && oldKey != REMOVED_KEY )
put( (K)oldKey, (V)oldData[ i + 1 ]);
}
}
public int getStartIndex( final Object key )
{
//key is not null here
return key.hashCode() & m_mask;
}
}
| {
"repo_name": "mikvor/hashmapTest",
"stars": "94",
"repo_language": "Java",
"file_name": "BaseIntIntMapTest.java",
"mime_type": "text/x-java"
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.