FwPatch: in-place delta update (detools 0.53.0 vendored), dry run predicts the real run
This commit is contained in:
1 parent
3cb3a458ce
commit
8d3e554ca3
14 files changed
+5159
No files matched your search
@@ -207,10 +207,12 @@ test_framework = googletest
|
||||
build_flags = -std=c++17
|
||||
-I src
|
||||
-I test/mocks
|
||||
-I src/helpers/fwpatch/detools/heatshrink
|
||||
test_build_src = yes
|
||||
test_ignore = test_kiss_modem
|
||||
build_src_filter =
|
||||
-<*>
|
||||
+<../src/helpers/FwPatch.c>
|
||||
+<../src/Utils.cpp>
|
||||
+<../src/Packet.cpp>
|
||||
+<../src/helpers/ConfigSerializer.cpp>
|
||||
@@ -229,6 +231,7 @@ test_framework = googletest
|
||||
build_flags = -std=c++17
|
||||
-I src
|
||||
-I test/mocks
|
||||
-I src/helpers/fwpatch/detools/heatshrink
|
||||
-fsanitize=address,undefined
|
||||
# Bez -fno-sanitize-recover UBSan nalez jen VYPISE a test dobehne uspesne --
|
||||
# takze z te poloviny sanitizeru byla jen ozdoba. ASAN abortuje sam.
|
||||
@@ -256,6 +259,7 @@ test_ignore =
|
||||
; jednotka.
|
||||
build_src_filter =
|
||||
-<*>
|
||||
+<../src/helpers/FwPatch.c>
|
||||
+<../src/Utils.cpp>
|
||||
+<../src/Packet.cpp>
|
||||
+<../src/helpers/ConfigSerializer.cpp>
|
||||
|
||||
@@ -0,0 +1,200 @@
|
||||
// CUSTOM (TeTeHacko): in-place delta update, see FwPatch.h.
|
||||
//
|
||||
// This translation unit compiles the vendored detools + heatshrink decoder
|
||||
// (src/helpers/fwpatch/detools, unmodified, see README.tth.md there) together
|
||||
// with the driver below. On the node tools/ota_ramlib.py moves the whole object
|
||||
// to RAM and redirects memcpy/memset to the local copies at the bottom, so not a
|
||||
// single instruction or table of the real run lives in the flash it rewrites
|
||||
// (tools/ota_check_ramfunc.sh checks the result).
|
||||
|
||||
// --- vendored code, configured here instead of editing it ------------------------
|
||||
#define HEATSHRINK_CONFIG_H // skip the vendored config, these values win
|
||||
#define HEATSHRINK_DYNAMIC_ALLOC 0
|
||||
#define HEATSHRINK_STATIC_INPUT_BUFFER_SIZE 256
|
||||
#define HEATSHRINK_STATIC_WINDOW_BITS 11 // tools/ota_pack.py must use the same
|
||||
#define HEATSHRINK_STATIC_LOOKAHEAD_BITS 10
|
||||
#define HEATSHRINK_DEBUGGING_LOGS 0
|
||||
#define HEATSHRINK_USE_INDEX 0
|
||||
|
||||
#define DETOOLS_CONFIG_FILE_IO 0
|
||||
#define DETOOLS_CONFIG_COMPRESSION_NONE 0
|
||||
#define DETOOLS_CONFIG_COMPRESSION_LZMA 0
|
||||
#define DETOOLS_CONFIG_COMPRESSION_CRLE 0
|
||||
#define DETOOLS_CONFIG_COMPRESSION_HEATSHRINK 1
|
||||
|
||||
#include "FwPatch.h"
|
||||
|
||||
#include "fwpatch/detools/detools.c"
|
||||
#include "fwpatch/detools/heatshrink/heatshrink_decoder.c"
|
||||
|
||||
// --- driver --------------------------------------------------------------------
|
||||
|
||||
static uint8_t g_page[FWP_PAGE];
|
||||
static struct detools_apply_patch_in_place_t g_dt;
|
||||
|
||||
#define NO_PAGE ((uintptr_t)-1)
|
||||
|
||||
static void fwp_copy(uint8_t *d, const uint8_t *s, uint32_t n) {
|
||||
while (n--)
|
||||
*d++ = *s++;
|
||||
}
|
||||
|
||||
static void flush_page(fwp_job *j) {
|
||||
if (j->page_addr == NO_PAGE) return;
|
||||
if (!j->dry) j->write(j->mem_base + j->page_addr, g_page, FWP_PAGE);
|
||||
j->page_addr = NO_PAGE;
|
||||
}
|
||||
|
||||
static int in_shift_phase(void) {
|
||||
return g_dt.state == detools_apply_patch_state_init_t;
|
||||
}
|
||||
|
||||
static int cb_read(void *arg, void *dst, uintptr_t src, size_t size) {
|
||||
fwp_job *j = (fwp_job *)arg;
|
||||
uint8_t *d = (uint8_t *)dst;
|
||||
if (src + size > j->mem_size) return j->err = FWP_ERR_ARGS;
|
||||
if (!in_shift_phase() && src < j->written_end) return j->err = FWP_ERR_OVERREAD;
|
||||
while (size > 0) {
|
||||
uintptr_t a = src;
|
||||
size_t n = size;
|
||||
if (j->dry && src >= j->shift_low && src < j->shift_high) {
|
||||
// the real run moved this page up by `shift`; the original still sits there
|
||||
a = src - j->shift;
|
||||
if (src + n > j->shift_high) n = j->shift_high - src;
|
||||
} else if (j->dry && src < j->shift_low && src + n > j->shift_low) {
|
||||
n = j->shift_low - src;
|
||||
}
|
||||
fwp_copy(d, (const uint8_t *)(j->mem_base + a), (uint32_t)n);
|
||||
d += n;
|
||||
src += n;
|
||||
size -= n;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cb_erase(void *arg, uintptr_t addr, size_t size) {
|
||||
fwp_job *j = (fwp_job *)arg;
|
||||
if ((addr % FWP_PAGE) != 0 || size == 0 || size > FWP_PAGE || addr + FWP_PAGE > j->mem_size)
|
||||
return j->err = FWP_ERR_ARGS;
|
||||
flush_page(j);
|
||||
if (j->tick) j->tick();
|
||||
if (in_shift_phase()) {
|
||||
if (j->dry) {
|
||||
if (addr < j->shift_low) j->shift_low = (uint32_t)addr;
|
||||
if (addr + FWP_PAGE > j->shift_high) j->shift_high = (uint32_t)(addr + FWP_PAGE);
|
||||
}
|
||||
} else {
|
||||
if (addr != j->written_end) return j->err = FWP_ERR_ORDER;
|
||||
j->written_end = (uint32_t)(addr + size);
|
||||
}
|
||||
if (!j->dry) j->erase(j->mem_base + addr);
|
||||
for (uint32_t i = 0; i < FWP_PAGE; i++)
|
||||
g_page[i] = 0xFF;
|
||||
j->page_addr = addr;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cb_write(void *arg, uintptr_t dst, void *src, size_t size) {
|
||||
fwp_job *j = (fwp_job *)arg;
|
||||
if (j->page_addr == NO_PAGE || dst < j->page_addr || dst + size > j->page_addr + FWP_PAGE)
|
||||
return j->err = FWP_ERR_ORDER;
|
||||
fwp_copy(&g_page[dst - j->page_addr], (const uint8_t *)src, (uint32_t)size);
|
||||
if (j->dry && !in_shift_phase()) j->sink(j->sink_ctx, (const uint8_t *)src, (uint32_t)size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int get_usize(const uint8_t *p, uint32_t n, uint32_t *pos, uint32_t *out) {
|
||||
uint32_t v = 0, off = 0;
|
||||
uint8_t b;
|
||||
if (*pos >= n) return -1;
|
||||
b = p[(*pos)++];
|
||||
if (b & 0x40) return -1; // negative
|
||||
v = b & 0x3f;
|
||||
off = 6;
|
||||
while (b & 0x80) {
|
||||
if (*pos >= n || off > 28) return -1;
|
||||
b = p[(*pos)++];
|
||||
v |= (uint32_t)(b & 0x7f) << off;
|
||||
off += 7;
|
||||
}
|
||||
*out = v;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fwp_header(const uint8_t *patch, uint32_t n, uint32_t *memory_size, uint32_t *segment_size,
|
||||
uint32_t *shift, uint32_t *from_size, uint32_t *to_size) {
|
||||
uint32_t pos = 1;
|
||||
if (n < 1 || ((patch[0] >> 4) & 0x7) != PATCH_TYPE_IN_PLACE) return -1;
|
||||
if ((patch[0] & 0xf) != COMPRESSION_HEATSHRINK) return -2;
|
||||
if (get_usize(patch, n, &pos, memory_size) || get_usize(patch, n, &pos, segment_size) ||
|
||||
get_usize(patch, n, &pos, shift) || get_usize(patch, n, &pos, from_size) ||
|
||||
get_usize(patch, n, &pos, to_size))
|
||||
return -3;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fwp_run(fwp_job *j) {
|
||||
uint32_t mem, seg, shift, from, to;
|
||||
int res;
|
||||
|
||||
j->err = 0;
|
||||
j->detools_err = 0;
|
||||
j->to_size = 0;
|
||||
j->page_addr = NO_PAGE;
|
||||
j->written_end = 0;
|
||||
j->shift_low = (uint32_t)-1;
|
||||
j->shift_high = 0;
|
||||
j->dt = &g_dt;
|
||||
|
||||
if ((j->mem_base % FWP_PAGE) != 0 || (j->mem_size % FWP_PAGE) != 0) return FWP_ERR_ARGS;
|
||||
if (j->dry ? j->sink == 0 : (j->erase == 0 || j->write == 0)) return FWP_ERR_ARGS;
|
||||
if (fwp_header(j->patch, j->patch_size, &mem, &seg, &shift, &from, &to) != 0) return FWP_ERR_ARGS;
|
||||
if (mem != j->mem_size || from != j->from_size || seg != FWP_PAGE) return FWP_ERR_SIZE;
|
||||
// shift 0 would make detools erase a page before reading it (shift loop)
|
||||
if (shift == 0 || (shift % FWP_PAGE) != 0 || to == 0 || to > mem) return FWP_ERR_SHIFT;
|
||||
j->shift = shift;
|
||||
|
||||
detools_apply_patch_in_place_init(&g_dt, cb_read, cb_write, cb_erase, NULL, NULL, j->patch_size, j);
|
||||
res = detools_apply_patch_in_place_process(&g_dt, j->patch, j->patch_size);
|
||||
if (res == 0) res = detools_apply_patch_in_place_finalize(&g_dt);
|
||||
if (j->err) return j->err; // ours is the more specific diagnosis
|
||||
if (res < 0) {
|
||||
j->detools_err = -res;
|
||||
return FWP_ERR_DETOOLS - (-res);
|
||||
}
|
||||
flush_page(j);
|
||||
if ((uint32_t)res != to || j->written_end < to) return FWP_ERR_SIZE;
|
||||
j->to_size = to;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// --- RAM copies of the two libc calls the compiler and detools emit -----------
|
||||
// tools/ota_ramlib.py renames memcpy/memset/memmove in this object to these, so
|
||||
// the real run never jumps back into flash libc.
|
||||
void *fwp_memcpy(void *d, const void *s, size_t n) {
|
||||
uint8_t *dd = (uint8_t *)d;
|
||||
const uint8_t *ss = (const uint8_t *)s;
|
||||
while (n--)
|
||||
*dd++ = *ss++;
|
||||
return d;
|
||||
}
|
||||
void *fwp_memset(void *d, int c, size_t n) {
|
||||
uint8_t *dd = (uint8_t *)d;
|
||||
while (n--)
|
||||
*dd++ = (uint8_t)c;
|
||||
return d;
|
||||
}
|
||||
void *fwp_memmove(void *d, const void *s, size_t n) {
|
||||
uint8_t *dd = (uint8_t *)d;
|
||||
const uint8_t *ss = (const uint8_t *)s;
|
||||
if (dd < ss) {
|
||||
while (n--)
|
||||
*dd++ = *ss++;
|
||||
} else {
|
||||
dd += n;
|
||||
ss += n;
|
||||
while (n--)
|
||||
*--dd = *--ss;
|
||||
}
|
||||
return d;
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
#pragma once
|
||||
|
||||
// CUSTOM (TeTeHacko): in-place delta update of the running image, the core of
|
||||
// FwUpdate's `format 2` packages. Plain C on purpose: the very same file runs in
|
||||
// the native unit test (fake flash) and on the node, where its code is moved to
|
||||
// RAM (tools/ota_ramlib.py), because a real run rewrites the flash the firmware
|
||||
// executes from.
|
||||
//
|
||||
// The patch is a detools "in-place" patch (heatshrink 11/10, segment = one flash
|
||||
// page). detools first moves the old image up by `shift` bytes, then writes the
|
||||
// new image page by page from the start, reading old bytes only above the page
|
||||
// it is writing. Two modes, one code path:
|
||||
//
|
||||
// dry no flash is touched. Reads from the shifted area are redirected to the
|
||||
// untouched original, every page of the new image goes to `sink` in
|
||||
// order (hash + CRC). A read the real run could not serve (data already
|
||||
// overwritten) fails the run. This is `fw verify`.
|
||||
// real erase/write through the callbacks, pages buffered in RAM so the flash
|
||||
// only ever sees whole, word-aligned pages. This is `fw apply`.
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define FWP_PAGE 4096u
|
||||
|
||||
// Error codes (negative). detools errors come through as -(100 + detools code).
|
||||
#define FWP_ERR_ARGS -1 // bad job (alignment, sizes)
|
||||
#define FWP_ERR_SHIFT -2 // shift not a positive multiple of a page
|
||||
#define FWP_ERR_OVERREAD -3 // the patch reads data a real run would have overwritten
|
||||
#define FWP_ERR_ORDER -4 // a write outside the page being built
|
||||
#define FWP_ERR_SIZE -5 // header sizes do not match the job
|
||||
#define FWP_ERR_DETOOLS -100
|
||||
|
||||
typedef struct fwp_job {
|
||||
// in
|
||||
uintptr_t mem_base; // address of memory offset 0 (APP_START on the node)
|
||||
uint32_t mem_size; // must equal the patch's memory_size
|
||||
uint32_t from_size; // must equal the patch's from_size (the running image)
|
||||
const uint8_t *patch; // memory-mapped patch
|
||||
uint32_t patch_size;
|
||||
int dry;
|
||||
void (*erase)(uintptr_t addr); // real: one page
|
||||
void (*write)(uintptr_t addr, const uint8_t *src, uint32_t n); // real: one page
|
||||
void (*sink)(void *ctx, const uint8_t *p, uint32_t n); // dry: new image, in order
|
||||
void *sink_ctx;
|
||||
void (*tick)(void); // optional, called once per page (watchdog)
|
||||
|
||||
// out
|
||||
uint32_t to_size; // size of the new image
|
||||
uint32_t shift;
|
||||
int detools_err;
|
||||
|
||||
// private
|
||||
void *dt; // struct detools_apply_patch_in_place_t *
|
||||
uintptr_t page_addr; // page being built (memory offset), or UINTPTR_MAX
|
||||
uint32_t shift_low; // shifted area so far, [shift_low, shift_high) (dry)
|
||||
uint32_t shift_high;
|
||||
uint32_t written_end; // end of the new image written so far (memory offset)
|
||||
int err;
|
||||
} fwp_job;
|
||||
|
||||
// Runs the whole patch. 0 = success (to_size set), negative = FWP_ERR_*.
|
||||
int fwp_run(fwp_job *j);
|
||||
|
||||
// Reads only the patch header: memory_size, segment_size, shift_size, from_size,
|
||||
// to_size. 0 on success. Used before the transfer completes and on the PC side
|
||||
// tests.
|
||||
int fwp_header(const uint8_t *patch, uint32_t n, uint32_t *memory_size, uint32_t *segment_size,
|
||||
uint32_t *shift, uint32_t *from_size, uint32_t *to_size);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,31 @@
|
||||
bsdiff/sais.c based on sais-lite 2.4.1 <https://sites.google.com/site/yuta256/sais>:
|
||||
Copyright (c) 2008-2010 Yuta Mori. (MIT License)
|
||||
|
||||
Other files:
|
||||
|
||||
BSD 2-Clause License
|
||||
|
||||
Copyright 2003-2005, Colin Percival (Original C implementation)
|
||||
Copyright (c) 2019, Erik Moqvist
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
||||
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
@@ -0,0 +1,15 @@
|
||||
# Vendored: detools 0.53.0 (C apply side) + heatshrink decoder
|
||||
|
||||
Source: https://github.com/eerimoq/detools, commit `53d1f47` (2025-12-17),
|
||||
files `c/detools.{c,h}` and `c/heatshrink/*`, copied **unmodified**.
|
||||
Licences: detools BSD-2-Clause (`LICENSE`, includes bsdiff/sais notices),
|
||||
heatshrink ISC (`heatshrink/README.rst`).
|
||||
|
||||
Used only by `src/helpers/FwPatch.c`, which `#include`s both `.c` files and
|
||||
configures them there (heatshrink 11/10 static, heatshrink-only detools, no
|
||||
file I/O) -- so nothing in this directory needs editing. Nothing here is in any
|
||||
`build_src_filter` on its own.
|
||||
|
||||
Updating: copy the same files from a new tag, then `pio test -e native -f
|
||||
test_fwpatch` and `-e native_asan`, and `tools/ota_check_ramfunc.sh` on a
|
||||
device build (the real run executes this code from RAM).
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,640 @@
|
||||
/**
|
||||
* BSD 2-Clause License
|
||||
*
|
||||
* Copyright (c) 2019-2020, Erik Moqvist
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* * Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
*
|
||||
* * Redistributions in binary form must reproduce the above copyright notice,
|
||||
* this list of conditions and the following disclaimer in the documentation
|
||||
* and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef DETOOLS_H
|
||||
#define DETOOLS_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Configuration.
|
||||
*
|
||||
* Define any of the defines below to 0 to disable given feature.
|
||||
*/
|
||||
|
||||
#ifndef DETOOLS_CONFIG_FILE_IO
|
||||
# define DETOOLS_CONFIG_FILE_IO 1
|
||||
#endif
|
||||
|
||||
#ifndef DETOOLS_CONFIG_COMPRESSION_NONE
|
||||
# define DETOOLS_CONFIG_COMPRESSION_NONE 1
|
||||
#endif
|
||||
|
||||
#ifndef DETOOLS_CONFIG_COMPRESSION_LZMA
|
||||
# define DETOOLS_CONFIG_COMPRESSION_LZMA 1
|
||||
#endif
|
||||
|
||||
#ifndef DETOOLS_CONFIG_COMPRESSION_CRLE
|
||||
# define DETOOLS_CONFIG_COMPRESSION_CRLE 1
|
||||
#endif
|
||||
|
||||
#ifndef DETOOLS_CONFIG_COMPRESSION_HEATSHRINK
|
||||
# define DETOOLS_CONFIG_COMPRESSION_HEATSHRINK 1
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#define DETOOLS_VERSION "0.53.0"
|
||||
|
||||
/* Error codes. */
|
||||
#define DETOOLS_OK 0
|
||||
#define DETOOLS_NOT_IMPLEMENTED 1
|
||||
#define DETOOLS_NOT_DONE 2
|
||||
#define DETOOLS_BAD_PATCH_TYPE 3
|
||||
#define DETOOLS_BAD_COMPRESSION 4
|
||||
#define DETOOLS_INTERNAL_ERROR 5
|
||||
#define DETOOLS_LZMA_INIT 6
|
||||
#define DETOOLS_LZMA_DECODE 7
|
||||
#define DETOOLS_OUT_OF_MEMORY 8
|
||||
#define DETOOLS_CORRUPT_PATCH 9
|
||||
#define DETOOLS_IO_FAILED 10
|
||||
#define DETOOLS_ALREADY_DONE 11
|
||||
#define DETOOLS_FILE_OPEN_FAILED 12
|
||||
#define DETOOLS_FILE_CLOSE_FAILED 13
|
||||
#define DETOOLS_FILE_READ_FAILED 14
|
||||
#define DETOOLS_FILE_WRITE_FAILED 15
|
||||
#define DETOOLS_FILE_SEEK_FAILED 16
|
||||
#define DETOOLS_FILE_TELL_FAILED 17
|
||||
#define DETOOLS_SHORT_HEADER 18
|
||||
#define DETOOLS_NOT_ENOUGH_PATCH_DATA 19
|
||||
#define DETOOLS_HEATSHRINK_SINK 20
|
||||
#define DETOOLS_HEATSHRINK_POLL 21
|
||||
#define DETOOLS_STEP_SET_FAILED 22
|
||||
#define DETOOLS_STEP_GET_FAILED 23
|
||||
#define DETOOLS_ALREADY_FAILED 24
|
||||
#define DETOOLS_CORRUPT_PATCH_OVERFLOW 25
|
||||
#define DETOOLS_CORRUPT_PATCH_CRLE_KIND 26
|
||||
#define DETOOLS_HEATSHRINK_HEADER 27
|
||||
|
||||
/**
|
||||
* Read callback.
|
||||
*
|
||||
* @param[in] arg_p User data passed to detools_apply_patch_init().
|
||||
* @param[out] buf_p Buffer to read into.
|
||||
* @param[in] size Number of bytes to read.
|
||||
*
|
||||
* @return zero(0) or negative error code.
|
||||
*/
|
||||
typedef int (*detools_read_t)(void *arg_p, uint8_t *buf_p, size_t size);
|
||||
|
||||
/**
|
||||
* Write callback.
|
||||
*
|
||||
* @param[in] arg_p User data passed to detools_apply_patch_init().
|
||||
* @param[in] buf_p Buffer to write.
|
||||
* @param[in] size Number of bytes to write.
|
||||
*
|
||||
* @return zero(0) or negative error code.
|
||||
*/
|
||||
typedef int (*detools_write_t)(void *arg_p, const uint8_t *buf_p, size_t size);
|
||||
|
||||
/**
|
||||
* Seek from current position callback.
|
||||
*
|
||||
* @param[in] arg_p User data passed to detools_apply_patch_init().
|
||||
* @param[in] offset Offset to seek to from current position.
|
||||
*
|
||||
* @return zero(0) or negative error code.
|
||||
*/
|
||||
typedef int (*detools_seek_t)(void *arg_p, int offset);
|
||||
|
||||
/**
|
||||
* Memory read callback.
|
||||
*
|
||||
* @param[in] arg_p User data passed to detools_apply_patch_init().
|
||||
* @param[out] dst_p Buffer to read into.
|
||||
* @param[in] src Address to read from.
|
||||
* @param[in] size Number of bytes to read.
|
||||
*
|
||||
* @return zero(0) or negative error code.
|
||||
*/
|
||||
typedef int (*detools_mem_read_t)(void *arg_p,
|
||||
void *dst_p,
|
||||
uintptr_t src,
|
||||
size_t size);
|
||||
|
||||
/**
|
||||
* Memory write callback.
|
||||
*
|
||||
* @param[in] arg_p User data passed to detools_apply_patch_init().
|
||||
* @param[in] dst Address to write to.
|
||||
* @param[in] addr src_p Buffer to write from.
|
||||
* @param[in] size Number of bytes to write.
|
||||
*
|
||||
* @return zero(0) or negative error code.
|
||||
*/
|
||||
typedef int (*detools_mem_write_t)(void *arg_p,
|
||||
uintptr_t dst,
|
||||
void *src_p,
|
||||
size_t size);
|
||||
|
||||
/**
|
||||
* Memory erase callback.
|
||||
*
|
||||
* @param[in] arg_p User data passed to detools_apply_patch_init().
|
||||
* @param[in] addr Address to erase from.
|
||||
* @param[in] size Number of bytes to erase.
|
||||
*
|
||||
* @return zero(0) or negative error code.
|
||||
*/
|
||||
typedef int (*detools_mem_erase_t)(void *arg_p, uintptr_t addr, size_t size);
|
||||
|
||||
/**
|
||||
* State read callback.
|
||||
*
|
||||
* @param[in] arg_p User data passed to detools_apply_patch_init().
|
||||
* @param[out] buf_p Buffer to read into.
|
||||
* @param[in] size Number of bytes to read.
|
||||
*
|
||||
* @return zero(0) or negative error code.
|
||||
*/
|
||||
typedef int (*detools_state_read_t)(void *arg_p, void *buf_p, size_t size);
|
||||
|
||||
/**
|
||||
* State write callback.
|
||||
*
|
||||
* @param[in] arg_p User data passed to detools_apply_patch_init().
|
||||
* @param[in] buf_p Buffer to write.
|
||||
* @param[in] size Number of bytes to write.
|
||||
*
|
||||
* @return zero(0) or negative error code.
|
||||
*/
|
||||
typedef int (*detools_state_write_t)(void *arg_p, const void *buf_p, size_t size);
|
||||
|
||||
/**
|
||||
* Step set callback.
|
||||
*
|
||||
* @param[in] arg_p User data passed to detools_apply_patch_init().
|
||||
* @param[in] step Step to set. Later read by the step get callback.
|
||||
*
|
||||
* @return zero(0) or negative error code.
|
||||
*/
|
||||
typedef int (*detools_step_set_t)(void *arg_p, int step);
|
||||
|
||||
/**
|
||||
* Step get callback.
|
||||
*
|
||||
* @param[in] arg_p User data passed to detools_apply_patch_init().
|
||||
* @param[out] step_p Outputs the most recently set step by the set
|
||||
* callback, or zero(0) if not yet set.
|
||||
*
|
||||
* @return zero(0) or negative error code.
|
||||
*/
|
||||
typedef int (*detools_step_get_t)(void *arg_p, int *step_p);
|
||||
|
||||
struct detools_apply_patch_size_t {
|
||||
int state;
|
||||
int value;
|
||||
int offset;
|
||||
bool is_signed;
|
||||
};
|
||||
|
||||
struct detools_apply_patch_patch_reader_none_t {
|
||||
size_t patch_size;
|
||||
size_t patch_offset;
|
||||
};
|
||||
|
||||
#if DETOOLS_CONFIG_COMPRESSION_LZMA == 1
|
||||
|
||||
#include <lzma.h>
|
||||
|
||||
struct detools_apply_patch_patch_reader_lzma_t {
|
||||
lzma_stream stream;
|
||||
uint8_t *input_p;
|
||||
uint8_t *output_p;
|
||||
size_t output_size;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#if DETOOLS_CONFIG_COMPRESSION_HEATSHRINK == 1
|
||||
|
||||
#include "heatshrink_decoder.h"
|
||||
|
||||
struct detools_apply_patch_patch_reader_heatshrink_t {
|
||||
int8_t window_sz2;
|
||||
int8_t lookahead_sz2;
|
||||
heatshrink_decoder *decoder_p;
|
||||
#if HEATSHRINK_DYNAMIC_ALLOC == 0
|
||||
heatshrink_decoder decoder;
|
||||
#endif
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
enum detools_unpack_usize_state_t {
|
||||
detools_unpack_usize_state_first_t = 0,
|
||||
detools_unpack_usize_state_consecutive_t
|
||||
};
|
||||
|
||||
struct detools_unpack_usize_t {
|
||||
enum detools_unpack_usize_state_t state;
|
||||
int value;
|
||||
int offset;
|
||||
};
|
||||
|
||||
enum detools_crle_state_t {
|
||||
detools_crle_state_idle_t = 0,
|
||||
detools_crle_state_scattered_size_t,
|
||||
detools_crle_state_scattered_data_t,
|
||||
detools_crle_state_repeated_repetitions_t,
|
||||
detools_crle_state_repeated_data_t,
|
||||
detools_crle_state_repeated_data_read_t
|
||||
};
|
||||
|
||||
struct detools_apply_patch_patch_reader_crle_t {
|
||||
enum detools_crle_state_t state;
|
||||
union {
|
||||
struct {
|
||||
size_t number_of_bytes_left;
|
||||
struct detools_unpack_usize_t size;
|
||||
} scattered;
|
||||
struct {
|
||||
uint8_t value;
|
||||
size_t number_of_bytes_left;
|
||||
struct detools_unpack_usize_t size;
|
||||
} repeated;
|
||||
} kind;
|
||||
};
|
||||
|
||||
struct detools_apply_patch_patch_reader_t {
|
||||
struct detools_apply_patch_chunk_t *patch_chunk_p;
|
||||
struct detools_apply_patch_size_t size;
|
||||
union {
|
||||
#if DETOOLS_CONFIG_COMPRESSION_NONE == 1
|
||||
struct detools_apply_patch_patch_reader_none_t none;
|
||||
#endif
|
||||
#if DETOOLS_CONFIG_COMPRESSION_LZMA == 1
|
||||
struct detools_apply_patch_patch_reader_lzma_t lzma;
|
||||
#endif
|
||||
#if DETOOLS_CONFIG_COMPRESSION_CRLE == 1
|
||||
struct detools_apply_patch_patch_reader_crle_t crle;
|
||||
#endif
|
||||
#if DETOOLS_CONFIG_COMPRESSION_HEATSHRINK == 1
|
||||
struct detools_apply_patch_patch_reader_heatshrink_t heatshrink;
|
||||
#endif
|
||||
} compression;
|
||||
int (*destroy)(struct detools_apply_patch_patch_reader_t *self_p);
|
||||
int (*decompress)(struct detools_apply_patch_patch_reader_t *self_p,
|
||||
uint8_t *buf_p,
|
||||
size_t *size_p);
|
||||
};
|
||||
|
||||
struct detools_apply_patch_chunk_t {
|
||||
const uint8_t *buf_p;
|
||||
size_t size;
|
||||
size_t offset;
|
||||
};
|
||||
|
||||
enum detools_apply_patch_state_t {
|
||||
detools_apply_patch_state_init_t = 0,
|
||||
detools_apply_patch_state_dfpatch_size_t,
|
||||
detools_apply_patch_state_diff_size_t,
|
||||
detools_apply_patch_state_diff_data_t,
|
||||
detools_apply_patch_state_extra_size_t,
|
||||
detools_apply_patch_state_extra_data_t,
|
||||
detools_apply_patch_state_adjustment_t,
|
||||
detools_apply_patch_state_done_t,
|
||||
detools_apply_patch_state_failed_t
|
||||
};
|
||||
|
||||
enum detools_apply_patch_init_state_t {
|
||||
detools_apply_patch_init_state_fixed_header_t = 0,
|
||||
detools_apply_patch_init_state_to_size_t
|
||||
};
|
||||
|
||||
/**
|
||||
* The apply patch data structure.
|
||||
*/
|
||||
struct detools_apply_patch_t {
|
||||
detools_read_t from_read;
|
||||
detools_seek_t from_seek;
|
||||
size_t patch_size;
|
||||
detools_write_t to_write;
|
||||
void *arg_p;
|
||||
enum detools_apply_patch_state_t state;
|
||||
enum detools_apply_patch_init_state_t init_state;
|
||||
int compression;
|
||||
size_t patch_offset;
|
||||
size_t to_offset;
|
||||
size_t to_size;
|
||||
int from_offset;
|
||||
size_t chunk_size;
|
||||
struct detools_apply_patch_patch_reader_t patch_reader;
|
||||
struct detools_apply_patch_chunk_t chunk;
|
||||
struct detools_apply_patch_size_t size;
|
||||
};
|
||||
|
||||
enum detools_apply_patch_in_place_init_state_t {
|
||||
detools_apply_patch_in_place_init_state_fixed_header_t = 0,
|
||||
detools_apply_patch_in_place_init_state_memory_size_t,
|
||||
detools_apply_patch_in_place_init_state_segment_size_t,
|
||||
detools_apply_patch_in_place_init_state_shift_size_t,
|
||||
detools_apply_patch_in_place_init_state_from_size_t,
|
||||
detools_apply_patch_in_place_init_state_to_size_t
|
||||
};
|
||||
|
||||
/**
|
||||
* The in-place apply patch data structure.
|
||||
*/
|
||||
struct detools_apply_patch_in_place_t {
|
||||
detools_mem_read_t mem_read;
|
||||
detools_mem_write_t mem_write;
|
||||
detools_mem_erase_t mem_erase;
|
||||
detools_step_set_t step_set;
|
||||
detools_step_get_t step_get;
|
||||
size_t patch_size;
|
||||
void *arg_p;
|
||||
enum detools_apply_patch_state_t state;
|
||||
enum detools_apply_patch_in_place_init_state_t init_state;
|
||||
int compression;
|
||||
int ongoing_step;
|
||||
size_t to_pos;
|
||||
size_t to_size;
|
||||
size_t from_size;
|
||||
size_t memory_size;
|
||||
size_t segment_size;
|
||||
size_t shift_size;
|
||||
size_t chunk_size;
|
||||
struct {
|
||||
size_t index;
|
||||
int from_offset;
|
||||
size_t to_offset;
|
||||
size_t to_size;
|
||||
size_t to_pos;
|
||||
} segment;
|
||||
struct detools_apply_patch_patch_reader_t patch_reader;
|
||||
struct detools_apply_patch_chunk_t chunk;
|
||||
struct detools_apply_patch_size_t size;
|
||||
};
|
||||
|
||||
/**
|
||||
* Initialize given apply patch object.
|
||||
*
|
||||
* @param[out] self_p Apply patch object to initialize.
|
||||
* @param[in] from_read Callback to read from-data.
|
||||
* @param[in] from_seek Callback to seek from current position in from-data.
|
||||
* @param[in] patch_size Patch size in bytes. Not used if
|
||||
* `detools_apply_patch_restore()` is called
|
||||
* immediately after this function.
|
||||
* @param[in] to_write Destination callback.
|
||||
* @param[in] arg_p Argument passed to the callbacks.
|
||||
*
|
||||
* @return zero(0) or negative error code.
|
||||
*/
|
||||
int detools_apply_patch_init(struct detools_apply_patch_t *self_p,
|
||||
detools_read_t from_read,
|
||||
detools_seek_t from_seek,
|
||||
size_t patch_size,
|
||||
detools_write_t to_write,
|
||||
void *arg_p);
|
||||
|
||||
/**
|
||||
* Dump given apply patch object state. Call
|
||||
* `detools_apply_patch_restore()` to restore an apply patch object to
|
||||
* the dumped state.
|
||||
*
|
||||
* @param[in] self_p Apply patch object to dump.
|
||||
* @param[in] write Write callback.
|
||||
*
|
||||
* @return zero(0) or negative error code.
|
||||
*/
|
||||
int detools_apply_patch_dump(struct detools_apply_patch_t *self_p,
|
||||
detools_state_write_t state_write);
|
||||
|
||||
/**
|
||||
* Restore given apply patch object to given dumped
|
||||
* state.
|
||||
*
|
||||
* `detools_apply_patch_get_to_offset()` and
|
||||
* `detools_apply_patch_get_patch_offset()` are often called after
|
||||
* this function to restore the to and patch streams.
|
||||
*
|
||||
* @param[in,out] self_p Initialized apply patch object to restore.
|
||||
* @param[in] read Callback to read the dumped state.
|
||||
*
|
||||
* @return zero(0) or negative error code.
|
||||
*/
|
||||
int detools_apply_patch_restore(struct detools_apply_patch_t *self_p,
|
||||
detools_state_read_t state_read);
|
||||
|
||||
/**
|
||||
* Get the current to stream offset. Often used to restore the to
|
||||
* stream after restore.
|
||||
*
|
||||
* @param[in] self_p Apply patch object.
|
||||
*
|
||||
* @return The current to stream offset.
|
||||
*/
|
||||
size_t detools_apply_patch_get_to_offset(struct detools_apply_patch_t *self_p);
|
||||
|
||||
/**
|
||||
* Get the current patch stream offset. Often used to restore the
|
||||
* patch stream after restore.
|
||||
*
|
||||
* @param[in] self_p Apply patch object.
|
||||
*
|
||||
* @return The current patch stream offset.
|
||||
*/
|
||||
size_t detools_apply_patch_get_patch_offset(struct detools_apply_patch_t *self_p);
|
||||
|
||||
/**
|
||||
* Call this function repeatedly until all patch data has been
|
||||
* processed or an error occurres. Call detools_apply_patch_finalize()
|
||||
* to finalize the patching, even if an error occurred.
|
||||
*
|
||||
* @param[in,out] self_p Initialized apply patch object.
|
||||
* @param[in] patch_p Next chunk of the patch.
|
||||
* @param[in] size Patch buffer size.
|
||||
*
|
||||
* @return zero(0) or negative error code.
|
||||
*/
|
||||
int detools_apply_patch_process(struct detools_apply_patch_t *self_p,
|
||||
const uint8_t *patch_p,
|
||||
size_t size);
|
||||
|
||||
/**
|
||||
* Call once after all data has been processed to finalize the
|
||||
* patching. The value returned from this function should be ignored
|
||||
* if an error occurred in detools_apply_patch_process().
|
||||
*
|
||||
* @param[in,out] self_p Initialized apply patch object.
|
||||
*
|
||||
* @return Size of to-data in bytes if the patch was applied
|
||||
* successfully, or negative error code.
|
||||
*/
|
||||
int detools_apply_patch_finalize(struct detools_apply_patch_t *self_p);
|
||||
|
||||
/**
|
||||
* Initialize given in-place apply patch object.
|
||||
*
|
||||
* @param[out] self_p In-place apply patch object to initialize.
|
||||
* @param[in] mem_read Callback to read data.
|
||||
* @param[in] mem_write Callback to write data.
|
||||
* @param[in] mem_erase Callback to erase data.
|
||||
* @param[in] step_set Callback to set the step.
|
||||
* @param[in] step_get Callback to get the step.
|
||||
* @param[in] patch_size Patch size in bytes.
|
||||
* @param[in] arg_p Argument passed to the callbacks.
|
||||
*
|
||||
* @return zero(0) or negative error code.
|
||||
*/
|
||||
int detools_apply_patch_in_place_init(
|
||||
struct detools_apply_patch_in_place_t *self_p,
|
||||
detools_mem_read_t mem_read,
|
||||
detools_mem_write_t mem_write,
|
||||
detools_mem_erase_t mem_erase,
|
||||
detools_step_set_t step_set,
|
||||
detools_step_get_t step_get,
|
||||
size_t patch_size,
|
||||
void *arg_p);
|
||||
|
||||
/**
|
||||
* Call this function repeatedly until all patch data has been
|
||||
* processed or an error occurres. Call
|
||||
* detools_apply_patch_in_place_finalize() to finalize the patching,
|
||||
* even if an error occurred.
|
||||
*
|
||||
* @param[in,out] self_p Initialized apply patch object.
|
||||
* @param[in] patch_p Next chunk of the patch.
|
||||
* @param[in] size Patch buffer size.
|
||||
*
|
||||
* @return zero(0) or negative error code.
|
||||
*/
|
||||
int detools_apply_patch_in_place_process(
|
||||
struct detools_apply_patch_in_place_t *self_p,
|
||||
const uint8_t *patch_p,
|
||||
size_t size);
|
||||
|
||||
/**
|
||||
* Call once after all data has been processed to finalize the
|
||||
* patching. The value returned from this function should be ignored
|
||||
* if an error occurred in detools_apply_patch_in_place_process().
|
||||
*
|
||||
* @param[in,out] self_p Initialized apply patch object.
|
||||
*
|
||||
* @return Size of to-data in bytes if the patch was applied
|
||||
* successfully, or negative error code.
|
||||
*/
|
||||
int detools_apply_patch_in_place_finalize(
|
||||
struct detools_apply_patch_in_place_t *self_p);
|
||||
|
||||
/**
|
||||
* Apply given patch using read, write and seek callbacks.
|
||||
*
|
||||
* @param[in] from_read Source read callback.
|
||||
* @param[in] from_seek Source seek callback.
|
||||
* @param[in] patch_read Patch read callback.
|
||||
* @param[in] patch_size Patch size in bytes.
|
||||
* @param[in] to_write Destination write callback.
|
||||
* @param[in] arg_p Argument passed to all callbacks.
|
||||
*
|
||||
* @return Size of to-data in bytes or negative error code.
|
||||
*/
|
||||
int detools_apply_patch_callbacks(detools_read_t from_read,
|
||||
detools_seek_t from_seek,
|
||||
detools_read_t patch_read,
|
||||
size_t patch_size,
|
||||
detools_write_t to_write,
|
||||
void *arg_p);
|
||||
|
||||
/**
|
||||
* Apply given in-place patch using read, write and erase callbacks.
|
||||
*
|
||||
* @param[in] mem_read Callback to read data.
|
||||
* @param[in] mem_write Callback to write data.
|
||||
* @param[in] mem_erase Callback to erase data.
|
||||
* @param[in] step_set Callback to set the step.
|
||||
* @param[in] step_get Callback to get the step.
|
||||
* @param[in] patch_read Patch read callback.
|
||||
* @param[in] patch_size Patch size in bytes.
|
||||
* @param[in] arg_p Argument passed to the callbacks.
|
||||
*
|
||||
* @return Size of to-data in bytes or negative error code.
|
||||
*/
|
||||
int detools_apply_patch_in_place_callbacks(detools_mem_read_t mem_read,
|
||||
detools_mem_write_t mem_write,
|
||||
detools_mem_erase_t mem_erase,
|
||||
detools_step_set_t step_set,
|
||||
detools_step_get_t step_get,
|
||||
detools_read_t patch_read,
|
||||
size_t patch_size,
|
||||
void *arg_p);
|
||||
|
||||
#if DETOOLS_CONFIG_FILE_IO == 1
|
||||
|
||||
/**
|
||||
* Apply given patch file to given from file and write the output to
|
||||
* given to file.
|
||||
*
|
||||
* @param[in] from_p Source file name.
|
||||
* @param[in] patch_p Patch file name.
|
||||
* @param[in] to_p Destination file name.
|
||||
*
|
||||
* @return Size of to-data in bytes or negative error code.
|
||||
*/
|
||||
int detools_apply_patch_filenames(const char *from_p,
|
||||
const char *patch_p,
|
||||
const char *to_p);
|
||||
|
||||
/**
|
||||
* Apply given patch file to given memory file.
|
||||
*
|
||||
* @param[in] memory_p Memory file name.
|
||||
* @param[in] patch_p Patch file name.
|
||||
* @param[in] step_set Callback to set the step.
|
||||
* @param[in] step_get Callback to get the step.
|
||||
*
|
||||
* @return Size of to-data in bytes or negative error code.
|
||||
*/
|
||||
int detools_apply_patch_in_place_filenames(const char *memory_p,
|
||||
const char *patch_p,
|
||||
detools_step_set_t step_set,
|
||||
detools_step_get_t step_get);
|
||||
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Get the error string for given error code.
|
||||
*
|
||||
* @param[in] Error code.
|
||||
*
|
||||
* @return Error string.
|
||||
*/
|
||||
const char *detools_error_as_string(int error);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,4 @@
|
||||
The files in this folder are copied from the heatshrink project,
|
||||
https://github.com/atomicobject/heatshrink.
|
||||
|
||||
Licensed under the ISC License.
|
||||
@@ -0,0 +1,20 @@
|
||||
#ifndef HEATSHRINK_H
|
||||
#define HEATSHRINK_H
|
||||
|
||||
#define HEATSHRINK_AUTHOR "Scott Vokes <scott.vokes@atomicobject.com>"
|
||||
#define HEATSHRINK_URL "https://github.com/atomicobject/heatshrink"
|
||||
|
||||
/* Version 0.4.1 */
|
||||
#define HEATSHRINK_VERSION_MAJOR 0
|
||||
#define HEATSHRINK_VERSION_MINOR 4
|
||||
#define HEATSHRINK_VERSION_PATCH 1
|
||||
|
||||
#define HEATSHRINK_MIN_WINDOW_BITS 4
|
||||
#define HEATSHRINK_MAX_WINDOW_BITS 15
|
||||
|
||||
#define HEATSHRINK_MIN_LOOKAHEAD_BITS 3
|
||||
|
||||
#define HEATSHRINK_LITERAL_MARKER 0x01
|
||||
#define HEATSHRINK_BACKREF_MARKER 0x00
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,26 @@
|
||||
#ifndef HEATSHRINK_CONFIG_H
|
||||
#define HEATSHRINK_CONFIG_H
|
||||
|
||||
/* Should functionality assuming dynamic allocation be used? */
|
||||
#ifndef HEATSHRINK_DYNAMIC_ALLOC
|
||||
#define HEATSHRINK_DYNAMIC_ALLOC 0
|
||||
#endif
|
||||
|
||||
#if HEATSHRINK_DYNAMIC_ALLOC
|
||||
/* Optional replacement of malloc/free */
|
||||
#define HEATSHRINK_MALLOC(SZ) malloc(SZ)
|
||||
#define HEATSHRINK_FREE(P, SZ) free(P)
|
||||
#else
|
||||
/* Required parameters for static configuration */
|
||||
#define HEATSHRINK_STATIC_INPUT_BUFFER_SIZE 256
|
||||
#define HEATSHRINK_STATIC_WINDOW_BITS 8
|
||||
#define HEATSHRINK_STATIC_LOOKAHEAD_BITS 7
|
||||
#endif
|
||||
|
||||
/* Turn on logging for debugging. */
|
||||
#define HEATSHRINK_DEBUGGING_LOGS 0
|
||||
|
||||
/* Use indexing for faster compression. (This requires additional space.) */
|
||||
#define HEATSHRINK_USE_INDEX 0
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,367 @@
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "heatshrink_decoder.h"
|
||||
|
||||
/* States for the polling state machine. */
|
||||
typedef enum {
|
||||
HSDS_TAG_BIT, /* tag bit */
|
||||
HSDS_YIELD_LITERAL, /* ready to yield literal byte */
|
||||
HSDS_BACKREF_INDEX_MSB, /* most significant byte of index */
|
||||
HSDS_BACKREF_INDEX_LSB, /* least significant byte of index */
|
||||
HSDS_BACKREF_COUNT_MSB, /* most significant byte of count */
|
||||
HSDS_BACKREF_COUNT_LSB, /* least significant byte of count */
|
||||
HSDS_YIELD_BACKREF, /* ready to yield back-reference */
|
||||
} HSD_state;
|
||||
|
||||
#if HEATSHRINK_DEBUGGING_LOGS
|
||||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
#include <assert.h>
|
||||
#define LOG(...) fprintf(stderr, __VA_ARGS__)
|
||||
#define ASSERT(X) assert(X)
|
||||
static const char *state_names[] = {
|
||||
"tag_bit",
|
||||
"yield_literal",
|
||||
"backref_index_msb",
|
||||
"backref_index_lsb",
|
||||
"backref_count_msb",
|
||||
"backref_count_lsb",
|
||||
"yield_backref",
|
||||
};
|
||||
#else
|
||||
#define LOG(...) /* no-op */
|
||||
#define ASSERT(X) /* no-op */
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
uint8_t *buf; /* output buffer */
|
||||
size_t buf_size; /* buffer size */
|
||||
size_t *output_size; /* bytes pushed to buffer, so far */
|
||||
} output_info;
|
||||
|
||||
#define NO_BITS ((uint16_t)-1)
|
||||
|
||||
/* Forward references. */
|
||||
static uint16_t get_bits(heatshrink_decoder *hsd, uint8_t count);
|
||||
static void push_byte(heatshrink_decoder *hsd, output_info *oi, uint8_t byte);
|
||||
|
||||
#if HEATSHRINK_DYNAMIC_ALLOC
|
||||
heatshrink_decoder *heatshrink_decoder_alloc(uint16_t input_buffer_size,
|
||||
uint8_t window_sz2,
|
||||
uint8_t lookahead_sz2) {
|
||||
if ((window_sz2 < HEATSHRINK_MIN_WINDOW_BITS) ||
|
||||
(window_sz2 > HEATSHRINK_MAX_WINDOW_BITS) ||
|
||||
(input_buffer_size == 0) ||
|
||||
(lookahead_sz2 < HEATSHRINK_MIN_LOOKAHEAD_BITS) ||
|
||||
(lookahead_sz2 >= window_sz2)) {
|
||||
return NULL;
|
||||
}
|
||||
size_t buffers_sz = (1 << window_sz2) + input_buffer_size;
|
||||
size_t sz = sizeof(heatshrink_decoder) + buffers_sz;
|
||||
heatshrink_decoder *hsd = HEATSHRINK_MALLOC(sz);
|
||||
if (hsd == NULL) { return NULL; }
|
||||
hsd->input_buffer_size = input_buffer_size;
|
||||
hsd->window_sz2 = window_sz2;
|
||||
hsd->lookahead_sz2 = lookahead_sz2;
|
||||
heatshrink_decoder_reset(hsd);
|
||||
LOG("-- allocated decoder with buffer size of %zu (%zu + %u + %u)\n",
|
||||
sz, sizeof(heatshrink_decoder), (1 << window_sz2), input_buffer_size);
|
||||
return hsd;
|
||||
}
|
||||
|
||||
void heatshrink_decoder_free(heatshrink_decoder *hsd) {
|
||||
size_t buffers_sz = (1 << hsd->window_sz2) + hsd->input_buffer_size;
|
||||
size_t sz = sizeof(heatshrink_decoder) + buffers_sz;
|
||||
HEATSHRINK_FREE(hsd, sz);
|
||||
(void)sz; /* may not be used by free */
|
||||
}
|
||||
#endif
|
||||
|
||||
void heatshrink_decoder_reset(heatshrink_decoder *hsd) {
|
||||
size_t buf_sz = 1 << HEATSHRINK_DECODER_WINDOW_BITS(hsd);
|
||||
size_t input_sz = HEATSHRINK_DECODER_INPUT_BUFFER_SIZE(hsd);
|
||||
memset(hsd->buffers, 0, buf_sz + input_sz);
|
||||
hsd->state = HSDS_TAG_BIT;
|
||||
hsd->input_size = 0;
|
||||
hsd->input_index = 0;
|
||||
hsd->bit_index = 0x00;
|
||||
hsd->current_byte = 0x00;
|
||||
hsd->output_count = 0;
|
||||
hsd->output_index = 0;
|
||||
hsd->head_index = 0;
|
||||
}
|
||||
|
||||
/* Copy SIZE bytes into the decoder's input buffer, if it will fit. */
|
||||
HSD_sink_res heatshrink_decoder_sink(heatshrink_decoder *hsd,
|
||||
uint8_t *in_buf, size_t size, size_t *input_size) {
|
||||
if ((hsd == NULL) || (in_buf == NULL) || (input_size == NULL)) {
|
||||
return HSDR_SINK_ERROR_NULL;
|
||||
}
|
||||
|
||||
size_t rem = HEATSHRINK_DECODER_INPUT_BUFFER_SIZE(hsd) - hsd->input_size;
|
||||
if (rem == 0) {
|
||||
*input_size = 0;
|
||||
return HSDR_SINK_FULL;
|
||||
}
|
||||
|
||||
size = rem < size ? rem : size;
|
||||
LOG("-- sinking %zd bytes\n", size);
|
||||
/* copy into input buffer (at head of buffers) */
|
||||
memcpy(&hsd->buffers[hsd->input_size], in_buf, size);
|
||||
hsd->input_size += size;
|
||||
*input_size = size;
|
||||
return HSDR_SINK_OK;
|
||||
}
|
||||
|
||||
|
||||
/*****************
|
||||
* Decompression *
|
||||
*****************/
|
||||
|
||||
#define BACKREF_COUNT_BITS(HSD) (HEATSHRINK_DECODER_LOOKAHEAD_BITS(HSD))
|
||||
#define BACKREF_INDEX_BITS(HSD) (HEATSHRINK_DECODER_WINDOW_BITS(HSD))
|
||||
|
||||
// States
|
||||
static HSD_state st_tag_bit(heatshrink_decoder *hsd);
|
||||
static HSD_state st_yield_literal(heatshrink_decoder *hsd,
|
||||
output_info *oi);
|
||||
static HSD_state st_backref_index_msb(heatshrink_decoder *hsd);
|
||||
static HSD_state st_backref_index_lsb(heatshrink_decoder *hsd);
|
||||
static HSD_state st_backref_count_msb(heatshrink_decoder *hsd);
|
||||
static HSD_state st_backref_count_lsb(heatshrink_decoder *hsd);
|
||||
static HSD_state st_yield_backref(heatshrink_decoder *hsd,
|
||||
output_info *oi);
|
||||
|
||||
HSD_poll_res heatshrink_decoder_poll(heatshrink_decoder *hsd,
|
||||
uint8_t *out_buf, size_t out_buf_size, size_t *output_size) {
|
||||
if ((hsd == NULL) || (out_buf == NULL) || (output_size == NULL)) {
|
||||
return HSDR_POLL_ERROR_NULL;
|
||||
}
|
||||
*output_size = 0;
|
||||
|
||||
output_info oi;
|
||||
oi.buf = out_buf;
|
||||
oi.buf_size = out_buf_size;
|
||||
oi.output_size = output_size;
|
||||
|
||||
while (1) {
|
||||
LOG("-- poll, state is %d (%s), input_size %d\n",
|
||||
hsd->state, state_names[hsd->state], hsd->input_size);
|
||||
uint8_t in_state = hsd->state;
|
||||
switch (in_state) {
|
||||
case HSDS_TAG_BIT:
|
||||
hsd->state = st_tag_bit(hsd);
|
||||
break;
|
||||
case HSDS_YIELD_LITERAL:
|
||||
hsd->state = st_yield_literal(hsd, &oi);
|
||||
break;
|
||||
case HSDS_BACKREF_INDEX_MSB:
|
||||
hsd->state = st_backref_index_msb(hsd);
|
||||
break;
|
||||
case HSDS_BACKREF_INDEX_LSB:
|
||||
hsd->state = st_backref_index_lsb(hsd);
|
||||
break;
|
||||
case HSDS_BACKREF_COUNT_MSB:
|
||||
hsd->state = st_backref_count_msb(hsd);
|
||||
break;
|
||||
case HSDS_BACKREF_COUNT_LSB:
|
||||
hsd->state = st_backref_count_lsb(hsd);
|
||||
break;
|
||||
case HSDS_YIELD_BACKREF:
|
||||
hsd->state = st_yield_backref(hsd, &oi);
|
||||
break;
|
||||
default:
|
||||
return HSDR_POLL_ERROR_UNKNOWN;
|
||||
}
|
||||
|
||||
/* If the current state cannot advance, check if input or output
|
||||
* buffer are exhausted. */
|
||||
if (hsd->state == in_state) {
|
||||
if (*output_size == out_buf_size) { return HSDR_POLL_MORE; }
|
||||
return HSDR_POLL_EMPTY;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static HSD_state st_tag_bit(heatshrink_decoder *hsd) {
|
||||
uint32_t bits = get_bits(hsd, 1); // get tag bit
|
||||
if (bits == NO_BITS) {
|
||||
return HSDS_TAG_BIT;
|
||||
} else if (bits) {
|
||||
return HSDS_YIELD_LITERAL;
|
||||
} else if (HEATSHRINK_DECODER_WINDOW_BITS(hsd) > 8) {
|
||||
return HSDS_BACKREF_INDEX_MSB;
|
||||
} else {
|
||||
hsd->output_index = 0;
|
||||
return HSDS_BACKREF_INDEX_LSB;
|
||||
}
|
||||
}
|
||||
|
||||
static HSD_state st_yield_literal(heatshrink_decoder *hsd,
|
||||
output_info *oi) {
|
||||
/* Emit a repeated section from the window buffer, and add it (again)
|
||||
* to the window buffer. (Note that the repetition can include
|
||||
* itself.)*/
|
||||
if (*oi->output_size < oi->buf_size) {
|
||||
uint16_t byte = get_bits(hsd, 8);
|
||||
if (byte == NO_BITS) { return HSDS_YIELD_LITERAL; } /* out of input */
|
||||
uint8_t *buf = &hsd->buffers[HEATSHRINK_DECODER_INPUT_BUFFER_SIZE(hsd)];
|
||||
uint16_t mask = (1 << HEATSHRINK_DECODER_WINDOW_BITS(hsd)) - 1;
|
||||
uint8_t c = byte & 0xFF;
|
||||
LOG("-- emitting literal byte 0x%02x ('%c')\n", c, isprint(c) ? c : '.');
|
||||
buf[hsd->head_index++ & mask] = c;
|
||||
push_byte(hsd, oi, c);
|
||||
return HSDS_TAG_BIT;
|
||||
} else {
|
||||
return HSDS_YIELD_LITERAL;
|
||||
}
|
||||
}
|
||||
|
||||
static HSD_state st_backref_index_msb(heatshrink_decoder *hsd) {
|
||||
uint8_t bit_ct = BACKREF_INDEX_BITS(hsd);
|
||||
ASSERT(bit_ct > 8);
|
||||
uint16_t bits = get_bits(hsd, bit_ct - 8);
|
||||
LOG("-- backref index (msb), got 0x%04x (+1)\n", bits);
|
||||
if (bits == NO_BITS) { return HSDS_BACKREF_INDEX_MSB; }
|
||||
hsd->output_index = bits << 8;
|
||||
return HSDS_BACKREF_INDEX_LSB;
|
||||
}
|
||||
|
||||
static HSD_state st_backref_index_lsb(heatshrink_decoder *hsd) {
|
||||
uint8_t bit_ct = BACKREF_INDEX_BITS(hsd);
|
||||
uint16_t bits = get_bits(hsd, bit_ct < 8 ? bit_ct : 8);
|
||||
LOG("-- backref index (lsb), got 0x%04x (+1)\n", bits);
|
||||
if (bits == NO_BITS) { return HSDS_BACKREF_INDEX_LSB; }
|
||||
hsd->output_index |= bits;
|
||||
hsd->output_index++;
|
||||
uint8_t br_bit_ct = BACKREF_COUNT_BITS(hsd);
|
||||
hsd->output_count = 0;
|
||||
return (br_bit_ct > 8) ? HSDS_BACKREF_COUNT_MSB : HSDS_BACKREF_COUNT_LSB;
|
||||
}
|
||||
|
||||
static HSD_state st_backref_count_msb(heatshrink_decoder *hsd) {
|
||||
uint8_t br_bit_ct = BACKREF_COUNT_BITS(hsd);
|
||||
ASSERT(br_bit_ct > 8);
|
||||
uint16_t bits = get_bits(hsd, br_bit_ct - 8);
|
||||
LOG("-- backref count (msb), got 0x%04x (+1)\n", bits);
|
||||
if (bits == NO_BITS) { return HSDS_BACKREF_COUNT_MSB; }
|
||||
hsd->output_count = bits << 8;
|
||||
return HSDS_BACKREF_COUNT_LSB;
|
||||
}
|
||||
|
||||
static HSD_state st_backref_count_lsb(heatshrink_decoder *hsd) {
|
||||
uint8_t br_bit_ct = BACKREF_COUNT_BITS(hsd);
|
||||
uint16_t bits = get_bits(hsd, br_bit_ct < 8 ? br_bit_ct : 8);
|
||||
LOG("-- backref count (lsb), got 0x%04x (+1)\n", bits);
|
||||
if (bits == NO_BITS) { return HSDS_BACKREF_COUNT_LSB; }
|
||||
hsd->output_count |= bits;
|
||||
hsd->output_count++;
|
||||
return HSDS_YIELD_BACKREF;
|
||||
}
|
||||
|
||||
static HSD_state st_yield_backref(heatshrink_decoder *hsd,
|
||||
output_info *oi) {
|
||||
size_t count = oi->buf_size - *oi->output_size;
|
||||
if (count > 0) {
|
||||
size_t i = 0;
|
||||
if (hsd->output_count < count) count = hsd->output_count;
|
||||
uint8_t *buf = &hsd->buffers[HEATSHRINK_DECODER_INPUT_BUFFER_SIZE(hsd)];
|
||||
uint16_t mask = (1 << HEATSHRINK_DECODER_WINDOW_BITS(hsd)) - 1;
|
||||
uint16_t neg_offset = hsd->output_index;
|
||||
LOG("-- emitting %zu bytes from -%u bytes back\n", count, neg_offset);
|
||||
ASSERT(neg_offset <= mask + 1);
|
||||
ASSERT(count <= (size_t)(1 << BACKREF_COUNT_BITS(hsd)));
|
||||
|
||||
for (i=0; i<count; i++) {
|
||||
uint8_t c = buf[(hsd->head_index - neg_offset) & mask];
|
||||
push_byte(hsd, oi, c);
|
||||
buf[hsd->head_index & mask] = c;
|
||||
hsd->head_index++;
|
||||
LOG(" -- ++ 0x%02x\n", c);
|
||||
}
|
||||
hsd->output_count -= count;
|
||||
if (hsd->output_count == 0) { return HSDS_TAG_BIT; }
|
||||
}
|
||||
return HSDS_YIELD_BACKREF;
|
||||
}
|
||||
|
||||
/* Get the next COUNT bits from the input buffer, saving incremental progress.
|
||||
* Returns NO_BITS on end of input, or if more than 15 bits are requested. */
|
||||
static uint16_t get_bits(heatshrink_decoder *hsd, uint8_t count) {
|
||||
uint16_t accumulator = 0;
|
||||
int i = 0;
|
||||
if (count > 15) { return NO_BITS; }
|
||||
LOG("-- popping %u bit(s)\n", count);
|
||||
|
||||
/* If we aren't able to get COUNT bits, suspend immediately, because we
|
||||
* don't track how many bits of COUNT we've accumulated before suspend. */
|
||||
if (hsd->input_size == 0) {
|
||||
if (hsd->bit_index < (1 << (count - 1))) { return NO_BITS; }
|
||||
}
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
if (hsd->bit_index == 0x00) {
|
||||
if (hsd->input_size == 0) {
|
||||
LOG(" -- out of bits, suspending w/ accumulator of %u (0x%02x)\n",
|
||||
accumulator, accumulator);
|
||||
return NO_BITS;
|
||||
}
|
||||
hsd->current_byte = hsd->buffers[hsd->input_index++];
|
||||
LOG(" -- pulled byte 0x%02x\n", hsd->current_byte);
|
||||
if (hsd->input_index == hsd->input_size) {
|
||||
hsd->input_index = 0; /* input is exhausted */
|
||||
hsd->input_size = 0;
|
||||
}
|
||||
hsd->bit_index = 0x80;
|
||||
}
|
||||
accumulator <<= 1;
|
||||
if (hsd->current_byte & hsd->bit_index) {
|
||||
accumulator |= 0x01;
|
||||
if (0) {
|
||||
LOG(" -- got 1, accumulator 0x%04x, bit_index 0x%02x\n",
|
||||
accumulator, hsd->bit_index);
|
||||
}
|
||||
} else {
|
||||
if (0) {
|
||||
LOG(" -- got 0, accumulator 0x%04x, bit_index 0x%02x\n",
|
||||
accumulator, hsd->bit_index);
|
||||
}
|
||||
}
|
||||
hsd->bit_index >>= 1;
|
||||
}
|
||||
|
||||
if (count > 1) { LOG(" -- accumulated %08x\n", accumulator); }
|
||||
return accumulator;
|
||||
}
|
||||
|
||||
HSD_finish_res heatshrink_decoder_finish(heatshrink_decoder *hsd) {
|
||||
if (hsd == NULL) { return HSDR_FINISH_ERROR_NULL; }
|
||||
switch (hsd->state) {
|
||||
case HSDS_TAG_BIT:
|
||||
return hsd->input_size == 0 ? HSDR_FINISH_DONE : HSDR_FINISH_MORE;
|
||||
|
||||
/* If we want to finish with no input, but are in these states, it's
|
||||
* because the 0-bit padding to the last byte looks like a backref
|
||||
* marker bit followed by all 0s for index and count bits. */
|
||||
case HSDS_BACKREF_INDEX_LSB:
|
||||
case HSDS_BACKREF_INDEX_MSB:
|
||||
case HSDS_BACKREF_COUNT_LSB:
|
||||
case HSDS_BACKREF_COUNT_MSB:
|
||||
return hsd->input_size == 0 ? HSDR_FINISH_DONE : HSDR_FINISH_MORE;
|
||||
|
||||
/* If the output stream is padded with 0xFFs (possibly due to being in
|
||||
* flash memory), also explicitly check the input size rather than
|
||||
* uselessly returning MORE but yielding 0 bytes when polling. */
|
||||
case HSDS_YIELD_LITERAL:
|
||||
return hsd->input_size == 0 ? HSDR_FINISH_DONE : HSDR_FINISH_MORE;
|
||||
|
||||
default:
|
||||
return HSDR_FINISH_MORE;
|
||||
}
|
||||
}
|
||||
|
||||
static void push_byte(heatshrink_decoder *hsd, output_info *oi, uint8_t byte) {
|
||||
LOG(" -- pushing byte: 0x%02x ('%c')\n", byte, isprint(byte) ? byte : '.');
|
||||
oi->buf[(*oi->output_size)++] = byte;
|
||||
(void)hsd;
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
#ifndef HEATSHRINK_DECODER_H
|
||||
#define HEATSHRINK_DECODER_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
#include "heatshrink_common.h"
|
||||
#include "heatshrink_config.h"
|
||||
|
||||
typedef enum {
|
||||
HSDR_SINK_OK, /* data sunk, ready to poll */
|
||||
HSDR_SINK_FULL, /* out of space in internal buffer */
|
||||
HSDR_SINK_ERROR_NULL=-1, /* NULL argument */
|
||||
} HSD_sink_res;
|
||||
|
||||
typedef enum {
|
||||
HSDR_POLL_EMPTY, /* input exhausted */
|
||||
HSDR_POLL_MORE, /* more data remaining, call again w/ fresh output buffer */
|
||||
HSDR_POLL_ERROR_NULL=-1, /* NULL arguments */
|
||||
HSDR_POLL_ERROR_UNKNOWN=-2,
|
||||
} HSD_poll_res;
|
||||
|
||||
typedef enum {
|
||||
HSDR_FINISH_DONE, /* output is done */
|
||||
HSDR_FINISH_MORE, /* more output remains */
|
||||
HSDR_FINISH_ERROR_NULL=-1, /* NULL arguments */
|
||||
} HSD_finish_res;
|
||||
|
||||
#if HEATSHRINK_DYNAMIC_ALLOC
|
||||
#define HEATSHRINK_DECODER_INPUT_BUFFER_SIZE(BUF) \
|
||||
((BUF)->input_buffer_size)
|
||||
#define HEATSHRINK_DECODER_WINDOW_BITS(BUF) \
|
||||
((BUF)->window_sz2)
|
||||
#define HEATSHRINK_DECODER_LOOKAHEAD_BITS(BUF) \
|
||||
((BUF)->lookahead_sz2)
|
||||
#else
|
||||
#define HEATSHRINK_DECODER_INPUT_BUFFER_SIZE(_) \
|
||||
HEATSHRINK_STATIC_INPUT_BUFFER_SIZE
|
||||
#define HEATSHRINK_DECODER_WINDOW_BITS(_) \
|
||||
(HEATSHRINK_STATIC_WINDOW_BITS)
|
||||
#define HEATSHRINK_DECODER_LOOKAHEAD_BITS(BUF) \
|
||||
(HEATSHRINK_STATIC_LOOKAHEAD_BITS)
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
uint16_t input_size; /* bytes in input buffer */
|
||||
uint16_t input_index; /* offset to next unprocessed input byte */
|
||||
uint16_t output_count; /* how many bytes to output */
|
||||
uint16_t output_index; /* index for bytes to output */
|
||||
uint16_t head_index; /* head of window buffer */
|
||||
uint8_t state; /* current state machine node */
|
||||
uint8_t current_byte; /* current byte of input */
|
||||
uint8_t bit_index; /* current bit index */
|
||||
|
||||
#if HEATSHRINK_DYNAMIC_ALLOC
|
||||
/* Fields that are only used if dynamically allocated. */
|
||||
uint8_t window_sz2; /* window buffer bits */
|
||||
uint8_t lookahead_sz2; /* lookahead bits */
|
||||
uint16_t input_buffer_size; /* input buffer size */
|
||||
|
||||
/* Input buffer, then expansion window buffer */
|
||||
uint8_t buffers[];
|
||||
#else
|
||||
/* Input buffer, then expansion window buffer */
|
||||
uint8_t buffers[(1 << HEATSHRINK_DECODER_WINDOW_BITS(_))
|
||||
+ HEATSHRINK_DECODER_INPUT_BUFFER_SIZE(_)];
|
||||
#endif
|
||||
} heatshrink_decoder;
|
||||
|
||||
#if HEATSHRINK_DYNAMIC_ALLOC
|
||||
/* Allocate a decoder with an input buffer of INPUT_BUFFER_SIZE bytes,
|
||||
* an expansion buffer size of 2^WINDOW_SZ2, and a lookahead
|
||||
* size of 2^lookahead_sz2. (The window buffer and lookahead sizes
|
||||
* must match the settings used when the data was compressed.)
|
||||
* Returns NULL on error. */
|
||||
heatshrink_decoder *heatshrink_decoder_alloc(uint16_t input_buffer_size,
|
||||
uint8_t expansion_buffer_sz2, uint8_t lookahead_sz2);
|
||||
|
||||
/* Free a decoder. */
|
||||
void heatshrink_decoder_free(heatshrink_decoder *hsd);
|
||||
#endif
|
||||
|
||||
/* Reset a decoder. */
|
||||
void heatshrink_decoder_reset(heatshrink_decoder *hsd);
|
||||
|
||||
/* Sink at most SIZE bytes from IN_BUF into the decoder. *INPUT_SIZE is set to
|
||||
* indicate how many bytes were actually sunk (in case a buffer was filled). */
|
||||
HSD_sink_res heatshrink_decoder_sink(heatshrink_decoder *hsd,
|
||||
uint8_t *in_buf, size_t size, size_t *input_size);
|
||||
|
||||
/* Poll for output from the decoder, copying at most OUT_BUF_SIZE bytes into
|
||||
* OUT_BUF (setting *OUTPUT_SIZE to the actual amount copied). */
|
||||
HSD_poll_res heatshrink_decoder_poll(heatshrink_decoder *hsd,
|
||||
uint8_t *out_buf, size_t out_buf_size, size_t *output_size);
|
||||
|
||||
/* Notify the dencoder that the input stream is finished.
|
||||
* If the return value is HSDR_FINISH_MORE, there is still more output, so
|
||||
* call heatshrink_decoder_poll and repeat. */
|
||||
HSD_finish_res heatshrink_decoder_finish(heatshrink_decoder *hsd);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,672 @@
|
||||
// GENERATED by tools/ota_fixtures.py -- do not edit.
|
||||
#pragma once
|
||||
#include <stdint.h>
|
||||
|
||||
// grow: old 60000 B, new 68192 B, memory 122880 B
|
||||
static const uint32_t fx_grow_mem = 122880;
|
||||
static const uint32_t fx_grow_old = 60000;
|
||||
static const uint32_t fx_grow_new = 68192;
|
||||
static const uint8_t fx_grow_patch[9594] = {
|
||||
0x14, 0x80, 0x80, 0x0f, 0x80, 0x40, 0x80, 0xc0, 0x07, 0xa0, 0xa9, 0x07, 0xa0, 0xa9, 0x08, 0x77,
|
||||
0x80, 0x60, 0x28, 0x08, 0x03, 0xff, 0x80, 0x07, 0xfe, 0x00, 0x1f, 0xf8, 0x00, 0x7f, 0xf0, 0x0e,
|
||||
0x05, 0x00, 0x01, 0x00, 0x2c, 0x05, 0x03, 0x11, 0x0e, 0x39, 0x0e, 0x1f, 0x71, 0x31, 0x95, 0x66,
|
||||
0xff, 0x5f, 0xb9, 0x6e, 0x03, 0xc1, 0x56, 0xd0, 0xc3, 0x66, 0x70, 0x3a, 0x0e, 0xeb, 0x15, 0x3f,
|
||||
0xca, 0xfa, 0x36, 0x93, 0x7f, 0x16, 0x8a, 0x3d, 0x05, 0xc6, 0x78, 0x21, 0x70, 0xc8, 0x1f, 0x6b,
|
||||
0x03, 0xb3, 0xac, 0xe2, 0x69, 0x33, 0xcf, 0x96, 0x83, 0x61, 0xad, 0xf3, 0x54, 0x23, 0x55, 0x0b,
|
||||
0x44, 0xdf, 0x45, 0x1d, 0xfb, 0xe6, 0xf2, 0xfb, 0xda, 0x6d, 0x43, 0x5b, 0x02, 0xee, 0x79, 0xad,
|
||||
0x12, 0xaa, 0x24, 0xab, 0xb5, 0x6b, 0xd5, 0x53, 0xb3, 0x96, 0x69, 0x85, 0x7f, 0x45, 0xac, 0xdd,
|
||||
0x7c, 0xb3, 0xf7, 0xdc, 0x96, 0x03, 0xed, 0x4f, 0xeb, 0x41, 0xf0, 0x51, 0x6f, 0x64, 0xbf, 0xd7,
|
||||
0x47, 0xa2, 0x40, 0x67, 0x54, 0x4c, 0x6f, 0xae, 0xbd, 0x51, 0x89, 0xd6, 0x3e, 0x7a, 0x8b, 0xef,
|
||||
0xf7, 0x81, 0x88, 0xff, 0x5e, 0xa6, 0xfd, 0x7f, 0x74, 0x0e, 0xf5, 0xfc, 0xd8, 0x48, 0xf5, 0x30,
|
||||
0x7a, 0xbc, 0x6e, 0xb7, 0x08, 0xbe, 0xe8, 0xb7, 0x3f, 0x7b, 0xac, 0x1b, 0x0f, 0x41, 0xf7, 0x44,
|
||||
0xaa, 0x3d, 0x4b, 0x84, 0xd6, 0x0f, 0x9f, 0xb5, 0xf8, 0x23, 0xbe, 0x39, 0x76, 0xda, 0xdd, 0x12,
|
||||
0xae, 0xfe, 0xba, 0xd2, 0x5a, 0x5f, 0x07, 0x81, 0x89, 0xfb, 0x53, 0xa1, 0xfd, 0x1c, 0x14, 0x57,
|
||||
0x6d, 0xd8, 0xfb, 0x59, 0xb3, 0x10, 0x38, 0xc4, 0xa2, 0xbd, 0x91, 0xd8, 0xe9, 0x3e, 0xb1, 0xc8,
|
||||
0x65, 0x9b, 0xd1, 0x95, 0xb8, 0x69, 0xf3, 0xb5, 0x99, 0xc6, 0x4b, 0x8f, 0xec, 0xe7, 0x51, 0x7c,
|
||||
0x99, 0x98, 0xbd, 0xbf, 0xa7, 0xe4, 0xdc, 0x53, 0xa7, 0x5d, 0xeb, 0xef, 0xe6, 0xef, 0x33, 0xca,
|
||||
0xd6, 0x30, 0x3d, 0x5e, 0x86, 0x37, 0x65, 0x1a, 0xf5, 0xf9, 0x24, 0x52, 0xa9, 0x3d, 0xce, 0x35,
|
||||
0xfc, 0xa3, 0x61, 0xad, 0xf6, 0xdd, 0x55, 0x1b, 0xbb, 0x97, 0xc3, 0xd2, 0xfd, 0xb6, 0x49, 0x67,
|
||||
0x6b, 0xaf, 0x54, 0xa6, 0xfa, 0x69, 0x7d, 0xea, 0x1c, 0x46, 0xaf, 0xdd, 0x84, 0xf3, 0xfa, 0x99,
|
||||
0x8b, 0xd7, 0x9f, 0x69, 0x42, 0xbe, 0xdd, 0x65, 0xd7, 0x9a, 0xaf, 0xc3, 0x41, 0xb6, 0x96, 0xf9,
|
||||
0x69, 0x7c, 0x39, 0x1d, 0x87, 0x93, 0x15, 0xd2, 0x63, 0x63, 0x1a, 0xe8, 0x4e, 0x12, 0x79, 0x74,
|
||||
0xf8, 0xce, 0xe8, 0xb2, 0xcd, 0xc4, 0xcf, 0x3f, 0xa1, 0xa9, 0x4f, 0xb0, 0x51, 0xee, 0x7e, 0x6b,
|
||||
0x99, 0xd0, 0xfc, 0x44, 0x22, 0x5d, 0xed, 0xbe, 0xde, 0xdd, 0xf3, 0xb5, 0x52, 0xbf, 0xd2, 0x0c,
|
||||
0x6c, 0x03, 0x09, 0xd0, 0xc8, 0x64, 0xb4, 0x52, 0x8b, 0x37, 0x2f, 0x1b, 0x69, 0x85, 0x6c, 0xaf,
|
||||
0xb4, 0x4f, 0x15, 0xce, 0xbb, 0x67, 0x9e, 0xfd, 0xe7, 0x76, 0xaa, 0xa5, 0xf2, 0xed, 0x46, 0xc1,
|
||||
0x6b, 0xa2, 0x38, 0xda, 0xf7, 0x23, 0xcd, 0xf0, 0x8d, 0xf4, 0xea, 0x92, 0xea, 0xcf, 0x87, 0xad,
|
||||
0xc3, 0x9a, 0x71, 0xa1, 0x7c, 0x39, 0x7c, 0xdb, 0x37, 0x5c, 0xf1, 0x57, 0xef, 0xf8, 0x4f, 0x8e,
|
||||
0x33, 0x33, 0xb7, 0xda, 0xed, 0xf9, 0x7f, 0x6b, 0x7f, 0x66, 0xff, 0x3f, 0x8a, 0xee, 0xb9, 0x30,
|
||||
0x19, 0xfc, 0xae, 0xa1, 0x52, 0xf1, 0x44, 0xed, 0xff, 0x2e, 0xbe, 0x52, 0x67, 0x9b, 0xf5, 0x61,
|
||||
0x70, 0x9d, 0xbf, 0x9e, 0x9f, 0xc7, 0xbb, 0xdf, 0xc7, 0x26, 0xf0, 0xea, 0x1f, 0xbb, 0xf5, 0x92,
|
||||
0xb8, 0x47, 0xac, 0x37, 0x7e, 0x3c, 0x3a, 0xd3, 0xb1, 0xc2, 0x59, 0xa6, 0xd1, 0xa9, 0x2e, 0x1a,
|
||||
0x79, 0x28, 0xde, 0x57, 0x67, 0xb6, 0xe8, 0x47, 0xbf, 0x09, 0xa9, 0xb5, 0x5a, 0x6f, 0xf8, 0xcb,
|
||||
0x9c, 0x1f, 0x6b, 0x18, 0xc1, 0x4f, 0x77, 0x5f, 0x4f, 0x2c, 0x7f, 0xb5, 0x63, 0x93, 0x60, 0xb6,
|
||||
0x50, 0x28, 0x8c, 0xee, 0x01, 0x0b, 0xba, 0xdf, 0xfa, 0x79, 0x69, 0xe5, 0xa2, 0xc5, 0xec, 0xa1,
|
||||
0xc5, 0x31, 0xd3, 0x0a, 0xe7, 0xa2, 0xbb, 0x69, 0xdf, 0xf8, 0x7b, 0x15, 0x2c, 0xc7, 0x83, 0x23,
|
||||
0x92, 0xe4, 0xe8, 0xb6, 0xde, 0x4c, 0xb4, 0x47, 0xb3, 0xd9, 0x92, 0x6a, 0x3a, 0xf5, 0x5a, 0xc4,
|
||||
0x47, 0x09, 0x65, 0xc5, 0xfc, 0xad, 0x7f, 0xed, 0x5c, 0x0a, 0x0f, 0xde, 0xf7, 0xdd, 0xf0, 0x93,
|
||||
0xa9, 0xa4, 0x8e, 0x3d, 0x75, 0xcb, 0xde, 0x66, 0x11, 0x2c, 0x35, 0x43, 0x6b, 0x54, 0xaa, 0xc8,
|
||||
0x2f, 0x91, 0x49, 0x4d, 0x4e, 0xbf, 0xff, 0x8e, 0xc2, 0xee, 0xb9, 0x6f, 0x55, 0x6b, 0xb3, 0xbb,
|
||||
0xad, 0xdf, 0xb7, 0x55, 0xee, 0xcd, 0xeb, 0x79, 0x63, 0xfd, 0x4e, 0x64, 0x7e, 0xca, 0xbe, 0x6b,
|
||||
0x53, 0x81, 0xad, 0x6c, 0x7e, 0x1b, 0x7c, 0x26, 0x93, 0x85, 0x63, 0xaf, 0x4e, 0x37, 0x59, 0x4d,
|
||||
0xe4, 0xc3, 0x07, 0x20, 0x90, 0x50, 0x2e, 0x3a, 0xea, 0x25, 0xc6, 0xc3, 0x31, 0xec, 0xd5, 0x22,
|
||||
0x75, 0x4e, 0xf5, 0xd6, 0xbb, 0x33, 0xd4, 0xf8, 0xf2, 0x3b, 0xeb, 0xee, 0x5f, 0x21, 0x77, 0xba,
|
||||
0xcc, 0x25, 0x1b, 0xbd, 0x57, 0x02, 0x17, 0xb8, 0xae, 0xeb, 0x60, 0xb2, 0xe9, 0xc4, 0xc7, 0x8f,
|
||||
0x96, 0xa4, 0xc1, 0xa4, 0x75, 0x6e, 0x44, 0x32, 0xbd, 0xf9, 0x9a, 0xef, 0x3b, 0x39, 0xdc, 0x8c,
|
||||
0x32, 0x4f, 0xee, 0x9a, 0xef, 0x64, 0x35, 0xde, 0x4d, 0x02, 0xab, 0xce, 0xaf, 0x4a, 0xab, 0x5e,
|
||||
0x48, 0xf5, 0x56, 0xe3, 0xb9, 0x95, 0x57, 0x69, 0x9a, 0xbe, 0x76, 0x5f, 0x59, 0x01, 0xf5, 0xd9,
|
||||
0xf4, 0x53, 0x0d, 0x24, 0x36, 0x85, 0x8a, 0xb0, 0xea, 0x36, 0x76, 0x7c, 0xbc, 0xcf, 0x69, 0x30,
|
||||
0xc1, 0xd3, 0x20, 0xdb, 0x2a, 0xdd, 0xd3, 0x01, 0x00, 0xf8, 0xf4, 0x63, 0x3d, 0x0e, 0x6d, 0x62,
|
||||
0xdb, 0xca, 0xa9, 0x7d, 0xae, 0xd1, 0xba, 0x26, 0x3a, 0x47, 0xea, 0xca, 0x57, 0xa8, 0x1d, 0x8b,
|
||||
0xbd, 0xa6, 0xf3, 0x0d, 0x92, 0x52, 0x73, 0x7b, 0x9f, 0xd7, 0x57, 0xeb, 0x82, 0xbd, 0xfb, 0x25,
|
||||
0x13, 0x2e, 0xed, 0x37, 0x3f, 0x75, 0x8f, 0xe3, 0x76, 0xdc, 0x3b, 0xd6, 0x92, 0xf3, 0xd7, 0xda,
|
||||
0xc9, 0x20, 0x5c, 0xa8, 0xb4, 0x12, 0x07, 0xec, 0xf8, 0xd6, 0xfe, 0x77, 0x6b, 0x8f, 0xf2, 0x1b,
|
||||
0x42, 0x9c, 0xe5, 0x2a, 0x5e, 0xfa, 0x36, 0x77, 0xc7, 0x3d, 0xff, 0x50, 0x3a, 0xfa, 0x2f, 0x3f,
|
||||
0x6a, 0xb9, 0x85, 0xa8, 0x71, 0x78, 0x5d, 0xda, 0xcd, 0x86, 0x3b, 0x7b, 0xdf, 0x67, 0x3b, 0xb8,
|
||||
0x7a, 0xec, 0xee, 0x89, 0x74, 0xd0, 0xe4, 0x63, 0x1a, 0xfb, 0x8d, 0xfb, 0x75, 0xee, 0xd0, 0xee,
|
||||
0xb5, 0x38, 0x89, 0x2f, 0x63, 0xd7, 0xd3, 0xe4, 0x6d, 0x27, 0xf6, 0xf9, 0xce, 0x6b, 0xdf, 0x3a,
|
||||
0xac, 0xe2, 0x30, 0xb7, 0x9c, 0x37, 0xe3, 0xb3, 0x8d, 0xef, 0x74, 0x6a, 0x99, 0x4e, 0x77, 0x2b,
|
||||
0xf1, 0x20, 0x90, 0xdb, 0xb1, 0x9f, 0xce, 0xfe, 0xa3, 0xa9, 0x30, 0xf7, 0x59, 0x2b, 0x11, 0x9e,
|
||||
0xcd, 0xef, 0xff, 0xce, 0xf0, 0x60, 0xfd, 0xff, 0x9d, 0x76, 0x07, 0x77, 0x08, 0x95, 0xef, 0xf1,
|
||||
0x36, 0xac, 0x16, 0x7e, 0x1d, 0x39, 0x8d, 0x6a, 0xaf, 0xb9, 0xaa, 0x66, 0xdf, 0x27, 0x64, 0xb0,
|
||||
0x65, 0xb2, 0xb3, 0x2a, 0x64, 0xae, 0x55, 0xee, 0xb2, 0xeb, 0xb1, 0x17, 0xff, 0x4e, 0x9f, 0x9d,
|
||||
0xb4, 0x97, 0x45, 0x6d, 0xd4, 0x9e, 0x5d, 0xbf, 0x27, 0x3a, 0xe6, 0x69, 0xf5, 0xf7, 0xcf, 0x1c,
|
||||
0x5b, 0xaf, 0x94, 0x84, 0x5e, 0xbe, 0x1c, 0xff, 0x4d, 0xd6, 0xa3, 0xc0, 0xcb, 0x5c, 0xe9, 0xd1,
|
||||
0x78, 0xe4, 0x8e, 0x27, 0x72, 0xc0, 0x7b, 0xad, 0xd1, 0xca, 0x67, 0x62, 0x09, 0xa0, 0xf2, 0xf8,
|
||||
0x38, 0x90, 0xc8, 0x9f, 0x8b, 0x5f, 0x17, 0xa1, 0xf9, 0x26, 0x7f, 0x5c, 0x7d, 0x13, 0x8d, 0x61,
|
||||
0x8b, 0x6f, 0x32, 0x59, 0xbc, 0xfc, 0x22, 0xf1, 0xec, 0x9a, 0xc5, 0x77, 0x34, 0x2f, 0x2e, 0x7a,
|
||||
0x13, 0xbf, 0x95, 0xd5, 0x68, 0x17, 0xfe, 0x8f, 0x63, 0xc3, 0x0b, 0x9c, 0x51, 0xe2, 0x39, 0xcd,
|
||||
0xc6, 0x22, 0x61, 0x5b, 0xd7, 0x6a, 0xa0, 0xfa, 0x5e, 0x55, 0xa7, 0xa5, 0x2a, 0xbc, 0xd5, 0x2a,
|
||||
0xb6, 0x58, 0xbd, 0x32, 0x3d, 0x8b, 0xa6, 0xda, 0x63, 0xd0, 0xfa, 0xb6, 0x6f, 0x2d, 0x9c, 0xb2,
|
||||
0xcf, 0x73, 0x97, 0xe8, 0xdc, 0x8a, 0x6b, 0x7a, 0x84, 0x56, 0x7e, 0xf3, 0x38, 0x5e, 0x17, 0x4b,
|
||||
0x87, 0xf1, 0x75, 0xa8, 0xf8, 0x5a, 0x65, 0x66, 0x05, 0xfc, 0xdd, 0x7d, 0x39, 0x7c, 0x9d, 0xfe,
|
||||
0xe6, 0x11, 0x2c, 0x95, 0x40, 0x3f, 0xbe, 0xca, 0x14, 0x1a, 0x39, 0xb5, 0xba, 0xf4, 0xe6, 0xb9,
|
||||
0xed, 0x06, 0x1e, 0x09, 0xac, 0xb2, 0xeb, 0xa3, 0xfa, 0xb9, 0x34, 0x32, 0xdb, 0xd8, 0xa2, 0x5b,
|
||||
0x77, 0x58, 0x78, 0x5c, 0x2e, 0x17, 0x85, 0xbe, 0xee, 0xbd, 0x3f, 0x5e, 0xa4, 0xdf, 0xed, 0x29,
|
||||
0x9d, 0x72, 0xbb, 0x73, 0x2e, 0x65, 0xb7, 0x49, 0xeb, 0xd7, 0x4f, 0x7a, 0x59, 0x8c, 0x9d, 0x56,
|
||||
0x61, 0xba, 0xd4, 0x7f, 0xa3, 0xdb, 0x8c, 0x6f, 0xe2, 0xcb, 0x0b, 0xdf, 0xec, 0x74, 0xdf, 0x8d,
|
||||
0x0d, 0xa2, 0xbb, 0xf2, 0x82, 0x55, 0xe3, 0x1d, 0x8b, 0xac, 0xdb, 0x47, 0x7a, 0x94, 0x79, 0xea,
|
||||
0x59, 0xed, 0xfc, 0xd6, 0x3d, 0x2e, 0x83, 0xe1, 0x69, 0x15, 0x5d, 0x1e, 0xd2, 0x19, 0x4e, 0xe6,
|
||||
0xd4, 0x72, 0x3d, 0x2e, 0x27, 0x22, 0xd3, 0xfb, 0xff, 0xd4, 0x25, 0x9d, 0x5b, 0x2c, 0x3f, 0x69,
|
||||
0xeb, 0xf7, 0xc9, 0x3a, 0x11, 0x9f, 0xad, 0xae, 0xa5, 0xc5, 0x85, 0xde, 0x63, 0x16, 0x6c, 0xc7,
|
||||
0xef, 0x61, 0x35, 0xec, 0x61, 0xec, 0x11, 0x1d, 0x06, 0xe3, 0x61, 0xb6, 0xce, 0x42, 0x25, 0x15,
|
||||
0xbc, 0x0c, 0x03, 0xf9, 0x4e, 0xd7, 0xf3, 0x7d, 0xb9, 0xda, 0x6e, 0xdb, 0x6d, 0x88, 0xe0, 0x42,
|
||||
0x25, 0xbf, 0xdf, 0x1e, 0xf6, 0xf7, 0xb2, 0xca, 0x71, 0x73, 0xbb, 0xdd, 0xc4, 0x52, 0x29, 0xe2,
|
||||
0x8a, 0xc5, 0xb7, 0x1f, 0xd9, 0x7c, 0xc3, 0x49, 0x37, 0xc8, 0xf5, 0xac, 0xd6, 0x18, 0xe5, 0xe3,
|
||||
0xdf, 0xc8, 0xe2, 0x4b, 0xae, 0xd3, 0x3e, 0x5d, 0xd2, 0x93, 0x7b, 0xd8, 0x6d, 0x62, 0x1b, 0x3c,
|
||||
0x16, 0x2e, 0x1f, 0xb0, 0xca, 0x7e, 0x23, 0x95, 0x29, 0xbd, 0x86, 0x25, 0x92, 0xbe, 0xc1, 0xb2,
|
||||
0x30, 0x3f, 0x2f, 0xf3, 0x89, 0x9d, 0xb3, 0xda, 0xf3, 0xb4, 0xbc, 0x27, 0x1e, 0xad, 0x1b, 0xa5,
|
||||
0x6e, 0x7d, 0xdc, 0xce, 0x27, 0x97, 0xe9, 0xca, 0x93, 0xf0, 0xa5, 0x70, 0x3f, 0xac, 0xe7, 0xc7,
|
||||
0x8d, 0x92, 0xe8, 0x33, 0xb8, 0x3d, 0x1c, 0x66, 0xfb, 0x39, 0xc8, 0x5d, 0x2b, 0xf5, 0x8b, 0xad,
|
||||
0xff, 0x05, 0x3b, 0x8b, 0x4a, 0x66, 0x5a, 0x8b, 0x8f, 0x6b, 0xd9, 0x24, 0xac, 0xfd, 0x30, 0x58,
|
||||
0xec, 0x7d, 0x7b, 0xdb, 0x2d, 0xc6, 0xcd, 0xb4, 0x3a, 0x3d, 0x37, 0xf6, 0x3b, 0x48, 0xed, 0x4c,
|
||||
0x3a, 0x7e, 0xad, 0xa7, 0x83, 0x25, 0x14, 0xd0, 0xda, 0xfe, 0x79, 0x0f, 0x6f, 0x43, 0x1d, 0x70,
|
||||
0xc5, 0x45, 0x6f, 0xd8, 0xea, 0x34, 0x07, 0xd5, 0x3c, 0x89, 0xf2, 0x21, 0x1f, 0x6a, 0x3f, 0x9f,
|
||||
0x3f, 0x7e, 0xbf, 0xdc, 0x2c, 0x58, 0x5b, 0x5c, 0xce, 0xa3, 0xc7, 0xbd, 0x62, 0xf3, 0x73, 0xdb,
|
||||
0x2e, 0x27, 0x85, 0x99, 0xc3, 0x73, 0xbb, 0xfa, 0x78, 0xd5, 0xea, 0x37, 0xf4, 0xd5, 0xf8, 0x71,
|
||||
0x3c, 0xc9, 0x56, 0x9e, 0xed, 0x56, 0x94, 0x4c, 0x28, 0xb5, 0xee, 0xf5, 0x76, 0x6d, 0x8c, 0xd8,
|
||||
0x4b, 0x32, 0x30, 0x48, 0xd6, 0xbb, 0xe9, 0x44, 0xfa, 0x58, 0xf8, 0xf9, 0x0a, 0xa7, 0xde, 0xc3,
|
||||
0x03, 0xad, 0x46, 0xec, 0x76, 0xf9, 0x74, 0xc6, 0x29, 0x75, 0x8a, 0xc2, 0x26, 0xf5, 0x7b, 0x14,
|
||||
0xa7, 0x0b, 0x23, 0xa6, 0xfc, 0x74, 0xb2, 0x0b, 0x5d, 0x57, 0x69, 0xd3, 0xe6, 0x73, 0x6a, 0xb3,
|
||||
0xaa, 0xac, 0x1a, 0xd7, 0xd9, 0xd5, 0x4e, 0x3c, 0x9c, 0x4c, 0x36, 0x6f, 0xad, 0xcb, 0xfb, 0xf1,
|
||||
0xb0, 0x11, 0xee, 0xdc, 0x5a, 0x0b, 0xe3, 0xc1, 0xfb, 0xe0, 0xb9, 0x3d, 0x7f, 0xaa, 0x83, 0x46,
|
||||
0x8b, 0xe6, 0xa7, 0xf6, 0xa9, 0x45, 0x7b, 0xe5, 0xf3, 0xb0, 0x60, 0x76, 0x16, 0x6f, 0x34, 0x26,
|
||||
0x6b, 0x05, 0xd1, 0xe8, 0x20, 0x1e, 0xce, 0xff, 0x5a, 0xbd, 0x63, 0xf0, 0xc2, 0x64, 0x16, 0xc9,
|
||||
0x17, 0x07, 0x3f, 0x74, 0x88, 0xf1, 0x3c, 0x57, 0x8b, 0xf7, 0x2f, 0xbf, 0x57, 0xb7, 0x4d, 0xae,
|
||||
0x72, 0x9c, 0x1c, 0xa6, 0xa3, 0x5d, 0xfa, 0x5d, 0xa3, 0xbb, 0x2d, 0xfe, 0x03, 0xd1, 0x26, 0xfa,
|
||||
0x41, 0xf3, 0xdc, 0x1f, 0xb5, 0x7e, 0xd9, 0x3b, 0x89, 0x4c, 0x6c, 0x9a, 0x39, 0xb4, 0x77, 0x69,
|
||||
0xb8, 0xbb, 0x4f, 0xbf, 0x39, 0x5b, 0x55, 0x53, 0x7d, 0xc8, 0xc8, 0xef, 0xf1, 0xf4, 0x7f, 0x04,
|
||||
0x17, 0x25, 0x8c, 0xe4, 0xde, 0xb7, 0x5d, 0x8f, 0x7d, 0x83, 0xe5, 0xbc, 0xbe, 0x65, 0xa2, 0xbf,
|
||||
0x5f, 0xde, 0x1b, 0x5d, 0xd4, 0xff, 0x48, 0xf0, 0xbb, 0x7a, 0x34, 0x1f, 0xd7, 0x67, 0x9e, 0x5e,
|
||||
0xb0, 0xda, 0x8f, 0xdc, 0x0f, 0x0f, 0x11, 0xc3, 0xd8, 0x72, 0x9e, 0x2c, 0x1e, 0x1b, 0x27, 0xbb,
|
||||
0xe8, 0xf3, 0x7b, 0x98, 0x59, 0x25, 0xb7, 0xed, 0x78, 0xf5, 0xed, 0x27, 0x13, 0xf8, 0x3e, 0x87,
|
||||
0xf5, 0x97, 0x97, 0xdc, 0xf7, 0xb7, 0x78, 0x64, 0xeb, 0xad, 0x82, 0xa1, 0x73, 0xad, 0x76, 0x3d,
|
||||
0x2d, 0x06, 0xd1, 0xfc, 0xb8, 0xc7, 0xe8, 0x3d, 0x8c, 0xad, 0x82, 0xad, 0x3b, 0x8a, 0x76, 0xbf,
|
||||
0xfe, 0x49, 0x9d, 0xf7, 0x37, 0xa4, 0xe8, 0x4b, 0x76, 0x5c, 0xeb, 0xe4, 0x83, 0x29, 0x62, 0xeb,
|
||||
0xe4, 0xb3, 0x36, 0xd9, 0x05, 0xa3, 0x5b, 0x93, 0xe7, 0xc6, 0xe5, 0x1d, 0x3f, 0xc6, 0x1e, 0x9d,
|
||||
0xb3, 0xbd, 0x5a, 0x37, 0xf0, 0x7e, 0xbe, 0xa2, 0xe3, 0x41, 0xbb, 0xd0, 0x31, 0xbb, 0x78, 0xf6,
|
||||
0x6e, 0x83, 0x71, 0x99, 0xd5, 0xbb, 0xf6, 0x1c, 0xc6, 0xbf, 0xab, 0xa4, 0x93, 0x77, 0xec, 0x12,
|
||||
0x78, 0xdf, 0x4b, 0xef, 0xf5, 0xd2, 0x6e, 0xa7, 0xbb, 0x0a, 0xc5, 0x3e, 0x67, 0x36, 0xa0, 0x45,
|
||||
0x79, 0x5a, 0x9f, 0x3c, 0xcb, 0xa5, 0x16, 0x8d, 0xda, 0xac, 0x57, 0x0d, 0xc4, 0x36, 0x59, 0x7f,
|
||||
0xe6, 0xc1, 0x73, 0x31, 0x0c, 0x6f, 0x22, 0x73, 0xc1, 0xc5, 0xf0, 0x26, 0x76, 0x19, 0x27, 0xfa,
|
||||
0x93, 0xf2, 0xb1, 0x49, 0xb8, 0x9d, 0x1b, 0xd5, 0xcf, 0x11, 0x1a, 0xc1, 0x41, 0xfe, 0x90, 0x8d,
|
||||
0xd5, 0x6a, 0x33, 0xa0, 0xda, 0xfc, 0xef, 0xb0, 0xf9, 0x8e, 0xa3, 0x0b, 0x65, 0xb6, 0xda, 0xea,
|
||||
0x92, 0x2e, 0x56, 0x5e, 0xbb, 0x45, 0xa6, 0x6c, 0xef, 0xdf, 0x6f, 0x47, 0xba, 0x3d, 0x62, 0xe4,
|
||||
0x69, 0x25, 0xff, 0xcb, 0x4e, 0x86, 0x45, 0x30, 0xbf, 0x56, 0xe8, 0x3d, 0x1c, 0x27, 0xdb, 0xa3,
|
||||
0x98, 0xa0, 0x70, 0xf4, 0x95, 0x68, 0xfe, 0x73, 0x35, 0xd1, 0xae, 0xe0, 0xf0, 0xb5, 0xae, 0x54,
|
||||
0x2f, 0xb9, 0xf4, 0xa5, 0x79, 0xb3, 0xbd, 0x19, 0x2f, 0xe2, 0xdb, 0x4b, 0xdd, 0x4a, 0x67, 0x5a,
|
||||
0x8f, 0x66, 0xcf, 0x95, 0x4b, 0x83, 0x75, 0x64, 0xb2, 0x5c, 0x85, 0x86, 0x67, 0xe8, 0xd2, 0xc7,
|
||||
0x3f, 0x75, 0x2e, 0xe6, 0x12, 0xeb, 0x8c, 0xd5, 0xc6, 0x2a, 0x76, 0xbd, 0x7e, 0xdb, 0x87, 0x60,
|
||||
0xc9, 0xe3, 0xaa, 0x70, 0x0e, 0x7c, 0xcb, 0xdb, 0x5a, 0xf4, 0xc0, 0xf6, 0x18, 0x7e, 0xfd, 0xbe,
|
||||
0xa9, 0x33, 0xa5, 0xdc, 0xed, 0x99, 0xb8, 0x2c, 0x3b, 0x81, 0x74, 0xea, 0xd2, 0xef, 0x50, 0x5e,
|
||||
0x4c, 0xc2, 0x35, 0x4a, 0xca, 0xc8, 0x24, 0x3a, 0x9e, 0x1c, 0xbf, 0x3f, 0x98, 0xdb, 0xd8, 0x6a,
|
||||
0x5f, 0xc8, 0xbc, 0xf3, 0x57, 0x3c, 0xea, 0x56, 0x69, 0x74, 0x49, 0xcf, 0xe2, 0x9f, 0x0e, 0x86,
|
||||
0x48, 0x7a, 0x1b, 0xda, 0x7e, 0xf3, 0xa9, 0xfe, 0xb5, 0xe0, 0xe4, 0x74, 0x19, 0xb6, 0xe6, 0x77,
|
||||
0xc8, 0xdd, 0xd7, 0xb1, 0x7d, 0xfd, 0xbc, 0x92, 0x37, 0x1c, 0xff, 0x71, 0x25, 0xf4, 0xdc, 0xc5,
|
||||
0xee, 0x11, 0x5d, 0x98, 0xd4, 0xea, 0x9b, 0x7c, 0xc6, 0xf3, 0xfb, 0x03, 0xa6, 0x6a, 0xf0, 0xdc,
|
||||
0x4d, 0xbf, 0x2f, 0x5f, 0x78, 0xd2, 0xce, 0xe6, 0xf1, 0x2d, 0x2f, 0x46, 0xb9, 0x05, 0xe7, 0x44,
|
||||
0xe4, 0x3a, 0x5d, 0x84, 0xf2, 0x59, 0xd7, 0xed, 0x41, 0xaf, 0xb4, 0x4d, 0x2f, 0x16, 0x35, 0x09,
|
||||
0xcd, 0x42, 0xe7, 0xdc, 0x5e, 0x77, 0x2b, 0x63, 0x37, 0xa7, 0x54, 0x76, 0xf2, 0x3e, 0x34, 0x16,
|
||||
0x71, 0x98, 0x81, 0xd9, 0x2d, 0x3f, 0xfd, 0x05, 0x1e, 0x71, 0xbe, 0xa5, 0xc9, 0xef, 0xb0, 0x78,
|
||||
0x3f, 0xea, 0x93, 0xe1, 0xe7, 0xd6, 0x75, 0x57, 0x5a, 0x3c, 0x67, 0x41, 0x5f, 0x9a, 0x66, 0xee,
|
||||
0xb2, 0x7a, 0xb5, 0x5a, 0xe7, 0x29, 0xb6, 0x6a, 0x2c, 0xfb, 0x9d, 0x8c, 0x7a, 0x45, 0x99, 0xb6,
|
||||
0xc9, 0xa2, 0xbc, 0x19, 0x76, 0x9e, 0xc5, 0x42, 0xbb, 0xd9, 0x7a, 0x10, 0xea, 0xa6, 0x82, 0xed,
|
||||
0xe8, 0x97, 0xc7, 0xb0, 0x7d, 0x3b, 0x77, 0x02, 0xb9, 0x07, 0x83, 0xd3, 0x77, 0xb4, 0x1e, 0x97,
|
||||
0x2e, 0x67, 0x90, 0x8a, 0x74, 0x6f, 0x79, 0xfe, 0xff, 0x3b, 0x83, 0x35, 0xf6, 0x76, 0x33, 0xb2,
|
||||
0x0a, 0x36, 0x87, 0x6f, 0x29, 0xdc, 0xc5, 0x2f, 0x5e, 0xff, 0x96, 0xbf, 0x67, 0x18, 0xc9, 0xe4,
|
||||
0xab, 0x7c, 0xaa, 0x46, 0xea, 0x5f, 0x6e, 0xa7, 0xe4, 0xa0, 0x70, 0xab, 0x9e, 0xd6, 0xf7, 0xe9,
|
||||
0x8a, 0xd3, 0x36, 0x7f, 0x39, 0x27, 0x82, 0x2b, 0x27, 0xc2, 0x70, 0xb4, 0x1e, 0x5b, 0x25, 0x2f,
|
||||
0x47, 0x1e, 0xba, 0x64, 0xa8, 0x5a, 0x69, 0x57, 0x22, 0xab, 0x5c, 0xf1, 0x68, 0xba, 0x9e, 0x6b,
|
||||
0xaf, 0x2e, 0x97, 0x4d, 0xf5, 0xfc, 0xaf, 0x38, 0xcd, 0x56, 0xdf, 0x47, 0x82, 0xc9, 0x79, 0xed,
|
||||
0x97, 0x88, 0x45, 0x37, 0x95, 0xf2, 0xcf, 0xfd, 0xfd, 0xf5, 0x49, 0x1d, 0xef, 0x27, 0x01, 0xe6,
|
||||
0x47, 0x78, 0x7d, 0x7d, 0x94, 0xae, 0x0f, 0x1f, 0xc1, 0xc0, 0x6c, 0xb7, 0xd8, 0x47, 0xcb, 0x8b,
|
||||
0xcf, 0xd6, 0xef, 0x64, 0x17, 0x09, 0xcc, 0x43, 0xe9, 0xfb, 0xf5, 0x63, 0xbf, 0x7c, 0x29, 0xdf,
|
||||
0x92, 0x97, 0xe7, 0x82, 0x62, 0x2f, 0x78, 0xf8, 0x75, 0x2a, 0x9f, 0xc2, 0xce, 0x54, 0xad, 0xbf,
|
||||
0xbe, 0x2f, 0x52, 0x8f, 0xec, 0xa1, 0xe8, 0x78, 0x56, 0x3e, 0xdc, 0xdb, 0xed, 0x83, 0xb8, 0xe3,
|
||||
0x3f, 0xf8, 0x28, 0x0e, 0x46, 0x73, 0x3a, 0xaf, 0xcc, 0xa0, 0xb9, 0x2d, 0x44, 0xe7, 0x11, 0x14,
|
||||
0xb7, 0x56, 0xb4, 0x33, 0xed, 0x9e, 0xa6, 0x9f, 0x51, 0x87, 0x4d, 0xb8, 0x7b, 0xad, 0x9e, 0xfb,
|
||||
0xc7, 0xe4, 0x9c, 0xc0, 0xe7, 0x9e, 0x99, 0x6f, 0x8f, 0x1f, 0x79, 0xe8, 0xd3, 0xfb, 0xbb, 0xda,
|
||||
0xd5, 0x02, 0xd9, 0x2c, 0x84, 0x60, 0x7f, 0xd6, 0xdc, 0x86, 0x06, 0xa3, 0x1e, 0x96, 0xd4, 0x2d,
|
||||
0x55, 0x4c, 0x2c, 0x23, 0x37, 0x70, 0xdd, 0x54, 0x3d, 0x5f, 0x0c, 0x86, 0x5f, 0x6b, 0x27, 0xc8,
|
||||
0x61, 0xbe, 0xf4, 0xa8, 0x95, 0x1b, 0xdf, 0x73, 0xd7, 0xe5, 0xe1, 0x10, 0x7f, 0xdd, 0x76, 0x5f,
|
||||
0x37, 0x8d, 0xde, 0xf6, 0x98, 0x2d, 0x3e, 0xe6, 0x79, 0x12, 0x95, 0xf6, 0xb6, 0x35, 0xe8, 0x5c,
|
||||
0x0a, 0x27, 0x4d, 0xd1, 0xf1, 0x71, 0xbf, 0x28, 0xbc, 0x96, 0x63, 0xa5, 0xf4, 0xf6, 0x2d, 0x34,
|
||||
0x49, 0x1c, 0x0f, 0x8f, 0xba, 0x95, 0xd2, 0xbe, 0x75, 0x4f, 0x5f, 0x77, 0xe3, 0x98, 0xde, 0x67,
|
||||
0x39, 0x14, 0xbc, 0x8d, 0x27, 0xfb, 0x68, 0xf6, 0x7e, 0x29, 0x55, 0x3a, 0x76, 0x63, 0x4b, 0x93,
|
||||
0xe5, 0x44, 0xe6, 0x11, 0x0a, 0x36, 0xde, 0x13, 0x2c, 0xf2, 0x7d, 0x34, 0x7c, 0x18, 0x26, 0xa7,
|
||||
0x69, 0xbf, 0xa6, 0xcf, 0xed, 0x5e, 0xef, 0x0d, 0xff, 0x1f, 0xf2, 0xa2, 0x7a, 0x3c, 0xfb, 0xab,
|
||||
0xdd, 0x5e, 0x57, 0xca, 0x8c, 0xfe, 0xed, 0x51, 0x2b, 0x37, 0xee, 0x5f, 0xb2, 0xc5, 0xf3, 0x7b,
|
||||
0x7c, 0x48, 0xc5, 0x83, 0xb7, 0x04, 0xea, 0xcc, 0xec, 0x96, 0x78, 0x4e, 0x6a, 0x91, 0x29, 0xd1,
|
||||
0xf3, 0x79, 0x34, 0x3d, 0x67, 0xae, 0xcd, 0xed, 0xc3, 0xe6, 0xea, 0xdc, 0x1a, 0x5d, 0x32, 0xdb,
|
||||
0x9d, 0x81, 0x63, 0x31, 0x1b, 0x18, 0x85, 0x87, 0xb5, 0x70, 0xe8, 0x51, 0x35, 0xd3, 0xec, 0x77,
|
||||
0x0e, 0x49, 0xc3, 0xb5, 0x5e, 0xed, 0x79, 0xce, 0x85, 0xdb, 0x6b, 0x92, 0xaa, 0xf5, 0xfc, 0xb7,
|
||||
0x78, 0x3c, 0x2a, 0xcb, 0xfd, 0xa8, 0xc7, 0xed, 0x5b, 0xfa, 0xcd, 0xdf, 0x67, 0x0d, 0xf0, 0x74,
|
||||
0x67, 0x16, 0x3e, 0xec, 0x9a, 0x1b, 0x4d, 0xba, 0x7a, 0x25, 0x14, 0x98, 0x94, 0xd6, 0x0d, 0xba,
|
||||
0xf0, 0x40, 0x3c, 0x51, 0x7d, 0xdd, 0x32, 0xf5, 0xae, 0xee, 0xd4, 0xf4, 0xf0, 0x8a, 0x7f, 0xf3,
|
||||
0x57, 0xc2, 0xdd, 0xe5, 0xba, 0x38, 0x59, 0x1c, 0xe3, 0xbb, 0xc0, 0xf4, 0xdd, 0x30, 0x76, 0x7d,
|
||||
0x5e, 0x2a, 0x37, 0x26, 0xbc, 0xf8, 0xb3, 0x3a, 0x38, 0x65, 0x2a, 0xab, 0xde, 0xa6, 0x6d, 0xef,
|
||||
0xf2, 0xfb, 0x75, 0x5f, 0xdd, 0x2f, 0xd8, 0xe8, 0xf5, 0x5a, 0x09, 0x57, 0x92, 0xc7, 0xe9, 0xa2,
|
||||
0xf7, 0xae, 0xb0, 0x8d, 0x65, 0x13, 0x8f, 0xab, 0x9e, 0xde, 0xa1, 0x97, 0x2e, 0xdd, 0x97, 0xab,
|
||||
0xf5, 0xe0, 0x73, 0x2f, 0x3b, 0x49, 0x94, 0x5e, 0xaf, 0xef, 0xed, 0x6f, 0x29, 0x9f, 0xa9, 0x67,
|
||||
0x5f, 0xdd, 0xd3, 0xfe, 0x7c, 0xe3, 0xf5, 0xbe, 0x0f, 0xdf, 0xe7, 0xb2, 0xb6, 0xd8, 0x24, 0x54,
|
||||
0x6f, 0x35, 0xf6, 0xd7, 0x8b, 0xcb, 0xf0, 0x6f, 0x5d, 0x2a, 0xb7, 0xde, 0x8b, 0x4f, 0x8c, 0xce,
|
||||
0xfb, 0x76, 0x6b, 0x5c, 0x4e, 0xe7, 0xf7, 0xa3, 0xcc, 0xe3, 0x7d, 0x4f, 0x4e, 0xb7, 0xdf, 0x1e,
|
||||
0x99, 0xdc, 0x7b, 0xf8, 0xa9, 0xac, 0x32, 0x8d, 0x57, 0xea, 0xe0, 0x62, 0x12, 0xca, 0x7e, 0xcf,
|
||||
0x29, 0x7b, 0xda, 0xf4, 0x35, 0x1e, 0xfe, 0x0f, 0x0b, 0x05, 0x04, 0xc4, 0xc9, 0x39, 0x3a, 0x79,
|
||||
0xfc, 0x82, 0x51, 0x03, 0xc7, 0xcf, 0xa5, 0x33, 0x09, 0xc5, 0xe3, 0x6d, 0xed, 0xa1, 0x61, 0xae,
|
||||
0x96, 0xbf, 0x8f, 0xd7, 0xcb, 0xa8, 0xaf, 0xdf, 0xa3, 0x9b, 0xae, 0xb6, 0xbb, 0x91, 0x4f, 0xac,
|
||||
0xd7, 0xf2, 0x14, 0x5f, 0x45, 0x33, 0xad, 0x78, 0xa9, 0x51, 0xac, 0x98, 0x39, 0x86, 0x2e, 0x17,
|
||||
0x1a, 0xb8, 0x60, 0xfb, 0x15, 0x4b, 0x07, 0xd2, 0xa7, 0x06, 0xbe, 0x77, 0x27, 0xbf, 0x5c, 0x26,
|
||||
0xd3, 0x0d, 0xce, 0xa1, 0xd8, 0xa4, 0xfd, 0x5c, 0x54, 0xe2, 0x0d, 0xc8, 0xd5, 0xe0, 0x2d, 0xbb,
|
||||
0xa8, 0x4e, 0xce, 0x81, 0xf9, 0xca, 0xdc, 0xfb, 0x39, 0xee, 0x35, 0x43, 0x3f, 0x3a, 0xdd, 0xde,
|
||||
0xe7, 0x36, 0x6d, 0x05, 0x4a, 0x4d, 0xc9, 0xef, 0x79, 0x6f, 0xb7, 0xe9, 0x37, 0x1b, 0x8b, 0x1e,
|
||||
0xf5, 0xea, 0xbb, 0xb8, 0xea, 0xcf, 0x77, 0x7f, 0x78, 0xcc, 0x50, 0x6f, 0x50, 0xdf, 0x94, 0x3e,
|
||||
0x35, 0xfe, 0xef, 0x54, 0xa2, 0xb0, 0x9c, 0x5d, 0x6a, 0x99, 0xda, 0xde, 0xd5, 0xba, 0xb7, 0x19,
|
||||
0xb5, 0xd6, 0xef, 0x55, 0xb7, 0x42, 0x71, 0x58, 0x08, 0xbf, 0x83, 0xef, 0xc6, 0xfb, 0xd7, 0x6a,
|
||||
0xd5, 0x89, 0x4f, 0x0a, 0x61, 0x61, 0x89, 0x5b, 0x3f, 0x1d, 0xba, 0xd4, 0x1b, 0x75, 0x5b, 0xa5,
|
||||
0x5b, 0x6e, 0x7c, 0xcd, 0xfe, 0x92, 0xe3, 0xb7, 0xc3, 0x4b, 0xe7, 0xb9, 0x7b, 0x06, 0xf2, 0x41,
|
||||
0x8d, 0xc1, 0xc0, 0x35, 0x32, 0xbd, 0x1e, 0x0b, 0x3d, 0x9b, 0xad, 0x48, 0xe6, 0x3e, 0x9d, 0xaf,
|
||||
0x2f, 0xc5, 0x47, 0x8d, 0x75, 0x3d, 0xd5, 0x4a, 0x17, 0x5b, 0x0f, 0x80, 0x93, 0x63, 0xbb, 0xde,
|
||||
0x79, 0x9f, 0x42, 0xab, 0x4a, 0xb0, 0xd7, 0xa2, 0x73, 0x2c, 0xd7, 0xbb, 0xd3, 0xb9, 0x9f, 0xe8,
|
||||
0xf9, 0x9b, 0x2a, 0x27, 0xff, 0x2f, 0xb6, 0x83, 0xc7, 0x60, 0xdb, 0xfa, 0x7f, 0x33, 0xa3, 0x90,
|
||||
0x8d, 0xc0, 0xe7, 0x3d, 0x1b, 0xa7, 0x03, 0xb1, 0x1f, 0x96, 0xdc, 0x7f, 0x31, 0x7c, 0x2d, 0x6f,
|
||||
0xf1, 0xd8, 0xd5, 0xc7, 0x39, 0xd8, 0x49, 0xed, 0x5a, 0xa3, 0x4e, 0xa9, 0xd3, 0xaf, 0x31, 0x5c,
|
||||
0xa4, 0x3a, 0x83, 0x1e, 0xd7, 0xf9, 0xa8, 0x9d, 0x0e, 0x47, 0xb7, 0xa3, 0x0d, 0xb7, 0x73, 0x63,
|
||||
0x76, 0xbb, 0x4d, 0x77, 0xa5, 0x87, 0xde, 0x7e, 0xbd, 0x16, 0xba, 0x65, 0xfa, 0x41, 0x69, 0xd0,
|
||||
0xf8, 0x75, 0xf3, 0x08, 0x1f, 0xdb, 0xe5, 0x9b, 0xd6, 0xd6, 0xa2, 0xfb, 0xcb, 0xd7, 0x57, 0x77,
|
||||
0x6e, 0xc2, 0x7c, 0xa4, 0x1a, 0x28, 0x46, 0xb3, 0x8b, 0x7a, 0xa5, 0x6d, 0x69, 0x13, 0xae, 0x47,
|
||||
0xe7, 0x1b, 0xa0, 0x84, 0x59, 0x2e, 0x39, 0x3d, 0x7d, 0x4f, 0x6b, 0xe6, 0xd6, 0xfa, 0xbd, 0x1a,
|
||||
0xf9, 0xe5, 0xc3, 0xad, 0xdd, 0xd1, 0xf0, 0xe0, 0x1c, 0x88, 0xe7, 0x6f, 0x6f, 0x51, 0x88, 0xfc,
|
||||
0xaf, 0x91, 0x7d, 0xb4, 0x9f, 0xfb, 0x4c, 0xc8, 0x6b, 0x3f, 0x5b, 0x69, 0x0e, 0x1e, 0x95, 0x67,
|
||||
0xab, 0x5c, 0x2a, 0xf4, 0xe9, 0x37, 0x66, 0x6d, 0x9c, 0x88, 0xe4, 0xa0, 0xf0, 0x7c, 0x3f, 0xeb,
|
||||
0x67, 0x32, 0xfd, 0xe9, 0x6c, 0xff, 0x99, 0x16, 0x76, 0xb7, 0x76, 0xf7, 0xf7, 0xf3, 0x57, 0x2c,
|
||||
0x57, 0x1e, 0xff, 0x04, 0xfb, 0xd6, 0x2e, 0x9e, 0x4e, 0x2c, 0xc7, 0x25, 0x09, 0xa8, 0x61, 0x2e,
|
||||
0x30, 0x4c, 0x34, 0x03, 0x23, 0x02, 0x9c, 0x53, 0x3b, 0xdb, 0xfc, 0x8e, 0x3f, 0x13, 0xc2, 0x92,
|
||||
0x65, 0x29, 0x93, 0x7a, 0xec, 0x2a, 0x45, 0x70, 0xa0, 0xfb, 0x37, 0xd0, 0x5d, 0x0c, 0xf6, 0x03,
|
||||
0xa1, 0xbf, 0x6c, 0x2e, 0x94, 0x5a, 0xcc, 0x77, 0xe7, 0x36, 0xde, 0x75, 0x6b, 0x36, 0x69, 0xfc,
|
||||
0x92, 0xcd, 0x13, 0xc7, 0xc0, 0xe0, 0x58, 0x3a, 0xf7, 0x9e, 0x0d, 0xb4, 0xe2, 0x7c, 0x7c, 0x98,
|
||||
0x19, 0x54, 0xa6, 0xd7, 0x11, 0x8b, 0x5f, 0x75, 0x56, 0x1e, 0x2e, 0x8f, 0x05, 0x06, 0xfe, 0x6e,
|
||||
0x73, 0x14, 0x1c, 0x3e, 0xc6, 0x7d, 0x17, 0xe9, 0x5e, 0xf5, 0xf9, 0x19, 0xd7, 0xc3, 0x83, 0xb1,
|
||||
0x80, 0x58, 0x71, 0x1d, 0x5e, 0x5c, 0x8e, 0x3d, 0x6c, 0xc5, 0xc4, 0xf2, 0xb3, 0x19, 0x9f, 0xba,
|
||||
0xab, 0xa3, 0x8e, 0xc6, 0xfe, 0xbf, 0x8a, 0x66, 0x02, 0x1b, 0xd5, 0xb5, 0x62, 0x7f, 0x18, 0xb9,
|
||||
0x5c, 0xf2, 0x27, 0xe5, 0x90, 0xfa, 0xbb, 0x16, 0x58, 0x34, 0xc2, 0x0f, 0xa9, 0xf8, 0x63, 0x7f,
|
||||
0x3d, 0x79, 0xa5, 0x7a, 0x91, 0x16, 0x87, 0x5f, 0xa4, 0x50, 0x0e, 0xb5, 0x46, 0x1f, 0x98, 0xfa,
|
||||
0x78, 0x64, 0x52, 0x9c, 0xee, 0xc7, 0x25, 0xb7, 0x97, 0x42, 0x33, 0xf6, 0x4a, 0x87, 0x66, 0x49,
|
||||
0x24, 0xcb, 0xd8, 0x38, 0x59, 0xbf, 0xf5, 0xe6, 0x81, 0x1d, 0xdf, 0xc2, 0xe6, 0x9f, 0x5c, 0x87,
|
||||
0xae, 0x4d, 0xaa, 0xe8, 0x79, 0x3b, 0xdb, 0x68, 0x95, 0x26, 0x13, 0x25, 0xc3, 0x74, 0x24, 0xbe,
|
||||
0x2b, 0xcc, 0x06, 0x95, 0x61, 0xd8, 0xfc, 0x20, 0x30, 0x08, 0x06, 0x02, 0x81, 0x87, 0x84, 0xdf,
|
||||
0x79, 0x77, 0xaa, 0x8e, 0x57, 0x1d, 0x3e, 0x94, 0xed, 0x64, 0x56, 0x48, 0xbc, 0xc2, 0xd9, 0xb6,
|
||||
0x85, 0x73, 0xec, 0xbd, 0xdf, 0x4c, 0xd3, 0x07, 0x13, 0xd4, 0x5c, 0xf2, 0x93, 0x59, 0xb6, 0xdf,
|
||||
0xc5, 0xf3, 0xa1, 0x4e, 0xfa, 0x79, 0x7c, 0x25, 0xdb, 0x37, 0xff, 0xa4, 0xc7, 0xf1, 0x77, 0x79,
|
||||
0xc7, 0x5b, 0xb3, 0xc6, 0xb3, 0x75, 0x30, 0x1a, 0xfe, 0x55, 0x27, 0xc3, 0x99, 0x8c, 0x4b, 0xb2,
|
||||
0x38, 0x98, 0xa7, 0x66, 0x59, 0x94, 0xd0, 0xe8, 0xa1, 0x70, 0x7f, 0x8d, 0x8a, 0xa3, 0xdd, 0xe3,
|
||||
0xc8, 0x71, 0x10, 0x2c, 0x5e, 0xd7, 0xb9, 0x9c, 0x96, 0x49, 0xe1, 0x5e, 0x4c, 0x37, 0xe2, 0x87,
|
||||
0x35, 0xc7, 0xf0, 0xf5, 0xb2, 0x18, 0x4d, 0x1e, 0x8f, 0x3b, 0x93, 0x65, 0x25, 0x30, 0x7f, 0x05,
|
||||
0x27, 0x9b, 0x36, 0xa5, 0xe2, 0x23, 0xfd, 0x9b, 0xe7, 0x77, 0x0d, 0x97, 0xe1, 0xfa, 0x28, 0x78,
|
||||
0xa9, 0x9d, 0x7b, 0xd7, 0xa9, 0xa4, 0x53, 0x64, 0xdb, 0x1a, 0x45, 0x46, 0x8b, 0xb3, 0x9f, 0x69,
|
||||
0xa6, 0xb3, 0xff, 0x97, 0x3a, 0xe1, 0x47, 0xd2, 0x5d, 0xa1, 0xbb, 0x8e, 0x4c, 0x7a, 0x49, 0xf5,
|
||||
0x81, 0xeb, 0x22, 0xdb, 0x3b, 0x2e, 0x3e, 0x19, 0xd6, 0xc4, 0x5b, 0xa9, 0x79, 0xbb, 0x34, 0x1f,
|
||||
0xb1, 0x8c, 0x85, 0x56, 0x60, 0xb8, 0x2f, 0xbf, 0xce, 0x8d, 0x89, 0x94, 0xe8, 0xbe, 0xb6, 0xbc,
|
||||
0x05, 0x7b, 0x5d, 0x0e, 0xf7, 0xdc, 0xa3, 0xf0, 0x58, 0xcc, 0x22, 0xfd, 0xfb, 0x92, 0x6a, 0x6b,
|
||||
0xbf, 0x3b, 0x6c, 0x2b, 0xe3, 0x38, 0x9b, 0xec, 0x69, 0x77, 0xda, 0x35, 0xfe, 0x03, 0x00, 0x88,
|
||||
0x55, 0x39, 0xf6, 0xdb, 0xe6, 0xff, 0x47, 0x2f, 0xa7, 0xf5, 0x61, 0x71, 0x3a, 0x16, 0xef, 0xe9,
|
||||
0x22, 0xa8, 0x42, 0x2e, 0x39, 0xfa, 0x95, 0xeb, 0xb3, 0x8b, 0xed, 0x42, 0xf2, 0x1f, 0x48, 0xdc,
|
||||
0x7e, 0x7f, 0x5b, 0xbf, 0x47, 0x65, 0xd2, 0x3e, 0xde, 0x1b, 0xab, 0xc9, 0xc5, 0x62, 0x30, 0x3c,
|
||||
0xc9, 0xac, 0xee, 0x39, 0x17, 0xd5, 0xec, 0xeb, 0xd7, 0x7a, 0x47, 0x5a, 0x85, 0xc3, 0x97, 0xd8,
|
||||
0xa0, 0xd9, 0x5e, 0xb5, 0x76, 0x0b, 0x09, 0x96, 0x47, 0x23, 0x14, 0x3a, 0x96, 0x8e, 0xe9, 0xc5,
|
||||
0xef, 0x4c, 0x20, 0x5f, 0x8a, 0x7d, 0xa6, 0xfd, 0x8f, 0x98, 0xe3, 0x7a, 0xf5, 0x9d, 0xa4, 0x2b,
|
||||
0x7b, 0x3e, 0xb5, 0xf2, 0xb5, 0x10, 0xfd, 0x9d, 0x1e, 0x13, 0xe5, 0x92, 0x7a, 0x3c, 0xd3, 0x0c,
|
||||
0xfd, 0x0a, 0x65, 0x9f, 0x9b, 0xd9, 0xfb, 0x99, 0xfa, 0x97, 0xdf, 0xff, 0x25, 0xa4, 0xf8, 0xe7,
|
||||
0xf6, 0x99, 0x96, 0x0b, 0x75, 0x6c, 0xd3, 0x5e, 0x21, 0x9f, 0x5e, 0x9f, 0x1e, 0xeb, 0x56, 0xd7,
|
||||
0x66, 0xfd, 0x71, 0x9b, 0x45, 0xf7, 0x7d, 0xed, 0xb4, 0x4b, 0xfc, 0x1a, 0x3e, 0x3f, 0xfe, 0x49,
|
||||
0x1c, 0xea, 0x48, 0xa0, 0xd9, 0xcb, 0x16, 0x1f, 0x87, 0x05, 0xa7, 0xc7, 0xeb, 0xf1, 0xd9, 0xbf,
|
||||
0x33, 0x71, 0x96, 0xad, 0x78, 0xad, 0x3b, 0x9f, 0xe7, 0x37, 0x2f, 0xa7, 0x87, 0x5f, 0xa6, 0x12,
|
||||
0xca, 0xf5, 0xd6, 0x8d, 0x34, 0x92, 0xf0, 0xaa, 0x93, 0x0d, 0x64, 0x5f, 0x31, 0xfb, 0xb6, 0x4e,
|
||||
0x37, 0x33, 0x1b, 0x7d, 0x46, 0xff, 0x49, 0xee, 0x48, 0xe8, 0x9b, 0xbf, 0xee, 0xd6, 0xc3, 0xcb,
|
||||
0xb3, 0xd0, 0x29, 0x11, 0x78, 0x6c, 0x3a, 0xcd, 0x9c, 0x93, 0xf0, 0xf5, 0xf8, 0x5c, 0x1f, 0x6a,
|
||||
0x8b, 0xd7, 0xc3, 0x68, 0xe2, 0xf3, 0x9e, 0x8c, 0x82, 0x31, 0xbe, 0xdb, 0xcb, 0x73, 0xdd, 0x7f,
|
||||
0xe5, 0x8a, 0xeb, 0xa7, 0x96, 0x79, 0x74, 0x30, 0x3a, 0x56, 0x13, 0x5d, 0xd7, 0xce, 0xea, 0x22,
|
||||
0x32, 0x4c, 0x25, 0xaa, 0xf1, 0x76, 0xf4, 0x72, 0xa1, 0x58, 0x6a, 0x3e, 0x5a, 0xb5, 0x5e, 0x96,
|
||||
0xf0, 0xa8, 0x1c, 0x9d, 0x55, 0x27, 0xbd, 0x45, 0xd9, 0xee, 0xad, 0x31, 0x7e, 0x06, 0xcb, 0x6b,
|
||||
0x55, 0xc1, 0xc4, 0xe4, 0x3e, 0x0a, 0x54, 0xbb, 0x61, 0xed, 0xae, 0xe6, 0xec, 0x52, 0xcf, 0x94,
|
||||
0x1f, 0x87, 0xb8, 0x8f, 0xcb, 0x75, 0xbe, 0x58, 0x2e, 0xe2, 0x95, 0x90, 0xb4, 0x41, 0xad, 0xd2,
|
||||
0x6e, 0x7f, 0x62, 0x4b, 0x9d, 0x85, 0xe1, 0x3c, 0x10, 0x6b, 0x5f, 0xef, 0xe3, 0xee, 0x98, 0x43,
|
||||
0x2f, 0xfc, 0x8a, 0x06, 0x5b, 0x6b, 0x97, 0x8c, 0xf0, 0xbc, 0xbf, 0x7c, 0x6e, 0x2b, 0xdb, 0x82,
|
||||
0xdd, 0xdc, 0x6c, 0x75, 0x78, 0x66, 0xee, 0x51, 0x31, 0x81, 0xd8, 0xeb, 0x9b, 0xed, 0xfc, 0xea,
|
||||
0xbb, 0xf4, 0xed, 0x7b, 0x34, 0x53, 0x8e, 0xcf, 0xcb, 0x7d, 0x08, 0xcc, 0x4a, 0xff, 0x74, 0x38,
|
||||
0x97, 0x26, 0x1b, 0x28, 0x82, 0x4f, 0x69, 0xbc, 0x08, 0x3d, 0x1e, 0x97, 0x84, 0xa6, 0x72, 0xf6,
|
||||
0x1a, 0x1c, 0x16, 0xf3, 0x97, 0xe9, 0xcd, 0x6d, 0x61, 0xfb, 0x2b, 0x4e, 0x0f, 0xad, 0xdd, 0xc1,
|
||||
0xd8, 0xa0, 0xb8, 0x4d, 0xc5, 0x8f, 0x97, 0xaf, 0xa2, 0x7e, 0xfb, 0x95, 0x1e, 0xfc, 0x66, 0xef,
|
||||
0x2f, 0x80, 0xf8, 0xa8, 0x5e, 0x19, 0xbf, 0x8e, 0x73, 0xac, 0xfd, 0x6e, 0xaf, 0x1d, 0x09, 0x06,
|
||||
0xee, 0xd1, 0xe3, 0xbf, 0x5c, 0x6a, 0x7b, 0xbf, 0x44, 0xfb, 0x57, 0xa5, 0xe6, 0xe6, 0xf7, 0x92,
|
||||
0x8f, 0x4f, 0x9a, 0xe7, 0xea, 0xa3, 0x4f, 0xa0, 0x94, 0xcb, 0xd7, 0xb2, 0x97, 0xd7, 0xf6, 0xe2,
|
||||
0xaa, 0xbb, 0xee, 0xf6, 0x3f, 0xe1, 0xcf, 0x9b, 0xd4, 0x71, 0x11, 0x4f, 0x6f, 0xf6, 0xcb, 0xf0,
|
||||
0x96, 0x41, 0x60, 0x3e, 0xa9, 0xe5, 0x43, 0x75, 0x83, 0xb2, 0xeb, 0x74, 0x16, 0x8b, 0xef, 0x9a,
|
||||
0xf1, 0x09, 0xad, 0xcb, 0x3c, 0x13, 0x6f, 0x0d, 0xe6, 0x05, 0x89, 0xc8, 0x5b, 0x60, 0x99, 0x1c,
|
||||
0xa5, 0x7b, 0xd3, 0x1b, 0x94, 0x4e, 0x2b, 0xd7, 0x5d, 0x1f, 0x97, 0x6f, 0xb9, 0xc4, 0x7a, 0xf3,
|
||||
0x3d, 0xce, 0x6d, 0xaf, 0xf5, 0xcf, 0xc9, 0xd2, 0x39, 0x96, 0x98, 0xc4, 0x8e, 0xa9, 0x46, 0xa3,
|
||||
0xc0, 0x2e, 0xb7, 0x8f, 0x7e, 0xbf, 0xc9, 0x81, 0xcb, 0xe3, 0xb2, 0x3b, 0x9c, 0x16, 0x4b, 0x05,
|
||||
0x93, 0xb2, 0xd0, 0x2f, 0x34, 0xbf, 0xe4, 0xb2, 0xa9, 0x53, 0x8a, 0x75, 0xea, 0x5f, 0xda, 0x67,
|
||||
0x27, 0x5d, 0x85, 0xcf, 0x54, 0x3c, 0x58, 0xe9, 0xb6, 0xd6, 0x35, 0x2e, 0xd7, 0xe9, 0xe5, 0xfb,
|
||||
0x0a, 0xa4, 0xef, 0x1f, 0x58, 0xb9, 0x6b, 0xec, 0xf7, 0xac, 0x17, 0x53, 0x4f, 0x68, 0xc4, 0xd3,
|
||||
0xa8, 0x5d, 0x9d, 0xaf, 0x52, 0x83, 0x69, 0x88, 0x65, 0xf8, 0x7a, 0x5f, 0x1c, 0xe2, 0xe9, 0xfd,
|
||||
0xfa, 0x70, 0xae, 0x1c, 0x88, 0x3f, 0x9b, 0x19, 0x92, 0xcc, 0xcd, 0x68, 0xf7, 0x3f, 0xaf, 0x17,
|
||||
0xa7, 0x69, 0xa6, 0xce, 0x3e, 0xd7, 0x9d, 0x14, 0xff, 0x69, 0xa2, 0xc4, 0xf1, 0xb5, 0x5d, 0x5a,
|
||||
0x5f, 0x0e, 0x85, 0xcc, 0xee, 0xe5, 0x63, 0xbc, 0x4b, 0x65, 0xba, 0x3f, 0xea, 0xaa, 0xcd, 0x3d,
|
||||
0xf5, 0xea, 0x35, 0x36, 0x0d, 0xa3, 0xff, 0xf9, 0x7a, 0x3d, 0xef, 0x45, 0xee, 0x17, 0x5b, 0x92,
|
||||
0xc5, 0x24, 0x5a, 0x6b, 0xdd, 0xba, 0xf3, 0x41, 0x95, 0x56, 0xe2, 0x36, 0x4e, 0xdd, 0x0f, 0x0f,
|
||||
0xe6, 0xb1, 0xf4, 0x2e, 0x96, 0x2a, 0x7c, 0x77, 0xcb, 0x35, 0xb7, 0x67, 0x77, 0xd6, 0x1a, 0x06,
|
||||
0xf7, 0xd5, 0x31, 0xf9, 0x58, 0x27, 0xf6, 0xe8, 0x0c, 0xf6, 0x1f, 0xf5, 0x89, 0x56, 0xb4, 0x90,
|
||||
0xcc, 0xce, 0x4f, 0xe5, 0x00, 0xe6, 0xfe, 0xa8, 0x33, 0x4c, 0x97, 0xbf, 0x7b, 0x31, 0xf3, 0x49,
|
||||
0x33, 0xdc, 0xbd, 0xe7, 0x36, 0xad, 0xaf, 0xd3, 0xd2, 0x7a, 0x70, 0x1f, 0x16, 0xd6, 0x9b, 0xd2,
|
||||
0xcb, 0x6f, 0xbb, 0x9f, 0x1d, 0xc6, 0xa7, 0x67, 0x4c, 0xb0, 0xe5, 0x69, 0x76, 0x88, 0x8f, 0xea,
|
||||
0x5d, 0x1e, 0xf2, 0x64, 0xe1, 0xf8, 0xda, 0xae, 0x23, 0xd9, 0x50, 0xfb, 0x63, 0x3e, 0x7e, 0x68,
|
||||
0x4f, 0x1b, 0x73, 0x6e, 0xa6, 0x7c, 0x29, 0xd7, 0xee, 0x2c, 0x0a, 0xbd, 0x50, 0x9b, 0x50, 0x74,
|
||||
0xd8, 0x59, 0x75, 0x46, 0x0d, 0x56, 0xaa, 0x6e, 0xe2, 0x94, 0x99, 0x5e, 0xce, 0x91, 0xfc, 0xd6,
|
||||
0x64, 0x23, 0x94, 0xfc, 0x47, 0x9b, 0x6f, 0x94, 0xbe, 0xe2, 0x6e, 0xf3, 0xea, 0xa5, 0xde, 0x5b,
|
||||
0x49, 0xc9, 0x76, 0x70, 0xba, 0x9f, 0x5c, 0xdf, 0x2d, 0xf1, 0xa6, 0x7d, 0x6f, 0x57, 0xae, 0x06,
|
||||
0x2e, 0xb3, 0xb1, 0xef, 0xf3, 0xa0, 0xd3, 0x9a, 0x6c, 0x4e, 0x7d, 0xa9, 0xa8, 0x7a, 0xa5, 0x9f,
|
||||
0xfc, 0xa4, 0x37, 0xc7, 0x83, 0xdb, 0x58, 0xea, 0x5c, 0xd8, 0xdd, 0x86, 0xf3, 0x75, 0xf6, 0x44,
|
||||
0xa4, 0x17, 0x0d, 0xf4, 0x03, 0xdb, 0x4d, 0xf6, 0xf8, 0xb8, 0xfe, 0xcb, 0x04, 0x2f, 0x11, 0x1a,
|
||||
0x90, 0x68, 0x78, 0xf4, 0x6a, 0xc4, 0x7e, 0xb5, 0xa7, 0xef, 0xd7, 0xba, 0x99, 0xd8, 0x46, 0x93,
|
||||
0xf7, 0x43, 0x8b, 0x4f, 0xab, 0x9f, 0x1c, 0x87, 0x4b, 0x7f, 0xe3, 0xc1, 0x56, 0x75, 0x39, 0xde,
|
||||
0x2d, 0x3a, 0x3b, 0x90, 0xa6, 0xf5, 0xe8, 0x5e, 0xee, 0x84, 0xda, 0xbf, 0x52, 0xd0, 0x60, 0xae,
|
||||
0x78, 0x8f, 0x5f, 0x9f, 0x4b, 0xa6, 0xf0, 0x6f, 0x3b, 0x9b, 0x3e, 0x14, 0xc3, 0x0f, 0xbb, 0x98,
|
||||
0x4a, 0xf5, 0xf8, 0x4f, 0x94, 0x7e, 0x0d, 0xb5, 0xd9, 0x6a, 0xa9, 0x71, 0x99, 0xe7, 0x8a, 0xd7,
|
||||
0x20, 0xb4, 0x6c, 0xfc, 0x39, 0xec, 0xc5, 0x17, 0x9d, 0xc9, 0xec, 0xd2, 0x3f, 0x97, 0x6a, 0x97,
|
||||
0x9b, 0x35, 0xa3, 0xe3, 0x7c, 0x73, 0x74, 0x3f, 0xbc, 0x06, 0x2b, 0xfd, 0x8d, 0xf7, 0xfa, 0xfc,
|
||||
0xdf, 0xd4, 0x0f, 0x85, 0xd8, 0x84, 0x76, 0x24, 0x9e, 0xbb, 0xbf, 0x9b, 0xd5, 0xd9, 0xb3, 0x6d,
|
||||
0xf2, 0x79, 0x38, 0xdd, 0xa7, 0x5d, 0x10, 0xc8, 0x6f, 0xfa, 0x95, 0xef, 0x47, 0x8f, 0x5d, 0x30,
|
||||
0xfb, 0xd0, 0x37, 0x51, 0xae, 0x07, 0x3f, 0x57, 0xd2, 0xea, 0xcf, 0x66, 0xb4, 0xee, 0x6f, 0xfb,
|
||||
0x9b, 0xba, 0x83, 0x6c, 0x30, 0xd9, 0xde, 0x97, 0x9e, 0x71, 0x3e, 0xb9, 0x6d, 0xfb, 0x79, 0x4e,
|
||||
0xce, 0x5b, 0x31, 0x66, 0xc4, 0x43, 0x67, 0x39, 0xd9, 0xa4, 0x6e, 0xbb, 0xa6, 0x8c, 0xf5, 0x69,
|
||||
0xd7, 0x98, 0x75, 0x52, 0x53, 0x34, 0xf8, 0xdb, 0x75, 0x90, 0xa8, 0xbc, 0xef, 0xeb, 0x93, 0xd2,
|
||||
0x44, 0xe7, 0x98, 0x08, 0xcc, 0x32, 0xbd, 0x34, 0xfd, 0x57, 0xf0, 0xb6, 0x9b, 0x16, 0xef, 0xa7,
|
||||
0xdf, 0xc0, 0xe3, 0x7f, 0xba, 0x9f, 0x35, 0xe3, 0x8b, 0xd2, 0x8b, 0xfa, 0xb2, 0x38, 0xeb, 0x84,
|
||||
0x4f, 0x0d, 0xb3, 0xf7, 0x7c, 0xf0, 0x75, 0x3f, 0x0e, 0x0a, 0x9b, 0x21, 0x92, 0xd0, 0xb1, 0x1c,
|
||||
0x1e, 0x1e, 0x0b, 0xf5, 0x09, 0xed, 0xdb, 0x64, 0xb6, 0x99, 0xed, 0x06, 0xd5, 0x0d, 0xa2, 0x4b,
|
||||
0x27, 0x13, 0xff, 0xfd, 0xbf, 0xe9, 0xab, 0xa7, 0xf4, 0xb4, 0x7c, 0x5f, 0x4f, 0x6b, 0x33, 0xc3,
|
||||
0xb7, 0x51, 0x34, 0x50, 0x58, 0x6c, 0x82, 0x15, 0x85, 0xa2, 0xdc, 0x2d, 0xfc, 0xcd, 0x35, 0xd2,
|
||||
0x87, 0xee, 0xfb, 0x42, 0x67, 0xf0, 0x5d, 0xdf, 0xbb, 0xc1, 0x05, 0x8e, 0x50, 0x69, 0xd1, 0xaf,
|
||||
0x77, 0x4b, 0xd1, 0xef, 0xef, 0xce, 0x6c, 0x34, 0x9b, 0xd7, 0x9e, 0x37, 0xee, 0xe1, 0xce, 0x3c,
|
||||
0x19, 0x58, 0x87, 0x97, 0xc1, 0x92, 0xee, 0x77, 0x3f, 0xd5, 0x9f, 0x37, 0x06, 0x39, 0x6a, 0xc0,
|
||||
0x60, 0xa6, 0x3d, 0xac, 0x56, 0x27, 0x79, 0x8f, 0xe9, 0x79, 0x67, 0xf9, 0x2b, 0x6d, 0xa2, 0x7b,
|
||||
0x69, 0xf1, 0xfa, 0xb1, 0xbf, 0xea, 0x4f, 0x2e, 0xf5, 0x11, 0x9e, 0x53, 0xea, 0x13, 0x9e, 0x36,
|
||||
0x22, 0x1f, 0x57, 0xcb, 0x4c, 0xed, 0xfe, 0x0b, 0xef, 0x66, 0x63, 0x69, 0x83, 0x41, 0x2f, 0xda,
|
||||
0xe9, 0xbe, 0x06, 0xad, 0x4e, 0xcb, 0x5c, 0x26, 0x3d, 0x1c, 0xed, 0x13, 0xe9, 0x02, 0x9d, 0x4a,
|
||||
0x24, 0x93, 0x5e, 0xfc, 0x3f, 0xcb, 0xc4, 0xf9, 0x4c, 0x7b, 0xf8, 0x7e, 0x16, 0xb7, 0x21, 0x12,
|
||||
0x9f, 0xd9, 0xfd, 0xf4, 0xcd, 0xf5, 0xce, 0x8d, 0x83, 0xb6, 0xf1, 0xf2, 0xf1, 0xac, 0xcf, 0x92,
|
||||
0xd3, 0x87, 0xb2, 0xcd, 0xa9, 0xb2, 0xb8, 0x94, 0x4a, 0xb9, 0xdd, 0xfb, 0xee, 0xf1, 0xff, 0x8c,
|
||||
0x57, 0x52, 0xc5, 0xa6, 0x80, 0x6a, 0xec, 0x31, 0xfb, 0xa5, 0xef, 0x7d, 0xfd, 0x90, 0xdb, 0x3e,
|
||||
0xf9, 0x08, 0x57, 0xbf, 0x17, 0x75, 0xce, 0x43, 0x77, 0x5b, 0xda, 0x14, 0x6b, 0x51, 0xec, 0xc9,
|
||||
0xea, 0x6a, 0xd3, 0xbb, 0xbc, 0xeb, 0xdb, 0x4c, 0xbf, 0x6f, 0xfc, 0x14, 0x18, 0x7e, 0xde, 0x45,
|
||||
0x1c, 0xb5, 0x44, 0x67, 0x7b, 0x2c, 0xec, 0xda, 0x89, 0x44, 0xcd, 0x6f, 0xa2, 0x9d, 0x0b, 0xef,
|
||||
0xf3, 0x8b, 0x52, 0xe6, 0x45, 0x61, 0x79, 0x0d, 0xdd, 0x1b, 0xe3, 0x7e, 0xdb, 0x71, 0xbb, 0x5b,
|
||||
0xdb, 0xa6, 0xa6, 0xd5, 0x70, 0xba, 0x52, 0x29, 0x5a, 0xba, 0xbc, 0xb7, 0xff, 0xa0, 0xdc, 0xff,
|
||||
0xe8, 0x5d, 0x1e, 0xc4, 0xe2, 0xe1, 0xeb, 0x99, 0x74, 0x76, 0x5b, 0xc8, 0xec, 0xdb, 0xf5, 0x7c,
|
||||
0xa3, 0xf9, 0xbd, 0x35, 0x6e, 0x04, 0xfa, 0xf7, 0x5c, 0x8d, 0xeb, 0x3a, 0x10, 0x59, 0x97, 0x8f,
|
||||
0x0b, 0xb8, 0x9c, 0xe9, 0xfc, 0x5d, 0x0a, 0x6e, 0xa3, 0xa3, 0x8f, 0xd0, 0xe0, 0xbf, 0xb3, 0x3a,
|
||||
0xfd, 0xb7, 0x47, 0xde, 0xee, 0xfb, 0x60, 0x59, 0x78, 0xa6, 0x8e, 0xed, 0x4d, 0x8c, 0xe1, 0xec,
|
||||
0xd0, 0x2c, 0xb7, 0x06, 0x1d, 0xce, 0xec, 0x60, 0xab, 0x77, 0x7a, 0x75, 0xe2, 0xa1, 0x86, 0xb0,
|
||||
0x4d, 0xf7, 0x96, 0x4e, 0x0f, 0x66, 0x2b, 0x93, 0xba, 0x66, 0xba, 0x9d, 0xfb, 0x36, 0xae, 0x23,
|
||||
0x32, 0xda, 0x48, 0x6c, 0x9a, 0xfe, 0xe7, 0xff, 0x51, 0x99, 0xb2, 0xe2, 0x30, 0x19, 0x59, 0xed,
|
||||
0x8b, 0x47, 0x13, 0x82, 0xed, 0xa7, 0xfa, 0xaa, 0xb4, 0xe2, 0x07, 0x1e, 0xdb, 0xf6, 0x6b, 0x1c,
|
||||
0x0c, 0x4c, 0xe2, 0x7d, 0x19, 0xb4, 0xf5, 0xbf, 0xd5, 0x7f, 0x04, 0x7a, 0x01, 0xba, 0xce, 0xc6,
|
||||
0xa2, 0xf0, 0xb8, 0x17, 0x92, 0xab, 0x6c, 0xbc, 0xf5, 0xfc, 0x90, 0xbd, 0xe5, 0x6e, 0x99, 0xc8,
|
||||
0x82, 0xed, 0xa6, 0xb5, 0xd8, 0x34, 0x57, 0x5f, 0xd6, 0xca, 0xca, 0xb5, 0xd1, 0xac, 0x87, 0xd7,
|
||||
0x35, 0xed, 0xab, 0x62, 0xfc, 0x31, 0xc8, 0x36, 0x43, 0xdf, 0x13, 0x80, 0xc8, 0xa1, 0x77, 0xbb,
|
||||
0xbd, 0xa2, 0x69, 0x01, 0x8b, 0xfc, 0x62, 0x3e, 0x6f, 0x7d, 0x6e, 0x09, 0x2e, 0x9a, 0xdb, 0xf2,
|
||||
0xd8, 0x39, 0x57, 0x23, 0x01, 0xde, 0x8e, 0x70, 0xa0, 0xb0, 0x2d, 0xcc, 0xc2, 0x99, 0x56, 0xbb,
|
||||
0x57, 0xb3, 0xf3, 0xcb, 0x06, 0x9a, 0x21, 0x47, 0xb7, 0x52, 0x7d, 0x18, 0x1d, 0xa5, 0x3b, 0x49,
|
||||
0x6d, 0xab, 0x78, 0x61, 0xbc, 0x6b, 0x55, 0x0b, 0x41, 0xd4, 0xc1, 0xc5, 0x7b, 0x5f, 0x8e, 0xcd,
|
||||
0x6b, 0x01, 0x62, 0xf2, 0x62, 0x6b, 0xbf, 0x2d, 0x6c, 0x5f, 0x03, 0xd0, 0xf5, 0xd7, 0xee, 0xf4,
|
||||
0x08, 0x67, 0x6e, 0x73, 0x19, 0xce, 0xff, 0x60, 0x5d, 0xed, 0xbf, 0xdf, 0xe5, 0x73, 0xb2, 0x72,
|
||||
0x39, 0xf9, 0xe9, 0xfc, 0x9f, 0x1f, 0x77, 0xbd, 0xf1, 0x31, 0x3f, 0xb8, 0x3f, 0x96, 0xb5, 0x51,
|
||||
0x97, 0xe5, 0x7c, 0xd9, 0x6e, 0x46, 0x62, 0xbf, 0xe8, 0x85, 0xe1, 0xea, 0xba, 0x2b, 0xcd, 0x37,
|
||||
0x87, 0x92, 0xc8, 0xcd, 0xf0, 0x9c, 0x2c, 0x06, 0xda, 0x35, 0x78, 0xa3, 0xe4, 0x2f, 0x78, 0x09,
|
||||
0xa6, 0x12, 0x79, 0x2c, 0xf0, 0xd0, 0x6f, 0xfc, 0x8c, 0xad, 0xd7, 0xad, 0x80, 0xa3, 0x76, 0x7e,
|
||||
0x3b, 0xfc, 0x27, 0xbb, 0x61, 0x59, 0x8e, 0xde, 0x33, 0xba, 0x8b, 0xa5, 0xbf, 0x67, 0xeb, 0xc8,
|
||||
0xe4, 0x7e, 0x3e, 0x28, 0x96, 0xc2, 0x95, 0x65, 0xa8, 0xfa, 0x61, 0x1a, 0x2c, 0x44, 0x3f, 0xd1,
|
||||
0xae, 0xfb, 0x67, 0x25, 0x70, 0xfa, 0x16, 0x6b, 0xf5, 0xc7, 0xea, 0x64, 0xe6, 0xbf, 0xdd, 0xe7,
|
||||
0xab, 0x47, 0xe1, 0x8a, 0x68, 0xb0, 0x50, 0x5e, 0x8f, 0xe3, 0xf9, 0xcf, 0x8a, 0xd0, 0xab, 0xfd,
|
||||
0xaf, 0x7f, 0x37, 0xd7, 0x49, 0xe8, 0xf2, 0x75, 0x70, 0xfc, 0x34, 0xaf, 0x27, 0x00, 0x81, 0xd9,
|
||||
0xa5, 0x3c, 0x29, 0xa4, 0xde, 0xd5, 0x10, 0xe4, 0x4c, 0x2c, 0x9f, 0x79, 0xd6, 0x7e, 0xf3, 0xd1,
|
||||
0x95, 0x48, 0x6b, 0xf6, 0xb9, 0x8d, 0x06, 0x2b, 0x6d, 0xac, 0x5d, 0xed, 0x12, 0xe9, 0xbe, 0xcb,
|
||||
0xf9, 0x17, 0xca, 0x6e, 0x2f, 0xde, 0x6f, 0x6f, 0x73, 0xeb, 0xaf, 0xae, 0x6d, 0x29, 0x50, 0x28,
|
||||
0xbd, 0x06, 0x07, 0xdf, 0xd9, 0x7e, 0xf1, 0x1d, 0xa8, 0xed, 0x82, 0x17, 0xd5, 0xf6, 0x7c, 0x2f,
|
||||
0x5b, 0xd8, 0x4e, 0xa6, 0x59, 0xd3, 0xee, 0xc5, 0x22, 0x17, 0x98, 0xb6, 0x8a, 0x9d, 0xe5, 0xf6,
|
||||
0xe4, 0x7b, 0x9e, 0xcd, 0x3c, 0x0a, 0x31, 0x60, 0xbf, 0xf2, 0x6e, 0xdd, 0x5e, 0x96, 0x57, 0x99,
|
||||
0xa6, 0xbd, 0xed, 0xb2, 0x75, 0x0a, 0x3d, 0xb6, 0x1f, 0x41, 0xab, 0xc6, 0xab, 0xfa, 0x6a, 0xcd,
|
||||
0x96, 0xcd, 0x88, 0x84, 0xef, 0x31, 0xfe, 0x1f, 0x4d, 0x43, 0x67, 0x01, 0xca, 0x52, 0x6c, 0x9b,
|
||||
0xaf, 0x5f, 0x87, 0x4b, 0xad, 0xf5, 0xd3, 0x67, 0xbb, 0xf9, 0x66, 0xba, 0xcb, 0x26, 0xd1, 0x7e,
|
||||
0x7a, 0x53, 0x78, 0xbf, 0xd6, 0x1b, 0x00, 0xdb, 0x7e, 0xaf, 0x35, 0x0a, 0xc4, 0x5b, 0xdf, 0x69,
|
||||
0xe0, 0xd5, 0xf6, 0x7a, 0x99, 0x4c, 0x8e, 0x51, 0x64, 0xf3, 0xe1, 0xef, 0x9d, 0xb9, 0x24, 0xff,
|
||||
0xb3, 0x39, 0xca, 0x44, 0x29, 0xbd, 0x0b, 0x6e, 0x6b, 0x2b, 0x3f, 0xbc, 0xf1, 0xaa, 0x3b, 0xa9,
|
||||
0xa5, 0x07, 0x33, 0x3f, 0xfa, 0x47, 0x70, 0xd7, 0x3b, 0xc7, 0x63, 0x53, 0xa0, 0xee, 0x6c, 0xbd,
|
||||
0xd1, 0x68, 0xb4, 0xf7, 0xbb, 0x66, 0x94, 0xd2, 0x77, 0xbc, 0xc9, 0xbc, 0xee, 0x11, 0x7b, 0xca,
|
||||
0xc3, 0x67, 0xd3, 0xab, 0xa7, 0xf6, 0x3b, 0xfd, 0xb0, 0x5a, 0x73, 0xfc, 0x98, 0x54, 0xf6, 0x65,
|
||||
0x6f, 0xdd, 0xc5, 0xf8, 0x15, 0x2c, 0x07, 0x07, 0x75, 0x7d, 0xe2, 0x70, 0xb7, 0x19, 0x2b, 0x77,
|
||||
0xbb, 0xcf, 0x57, 0xbc, 0x74, 0xbd, 0xfc, 0xca, 0x26, 0xb6, 0xd1, 0x42, 0xf5, 0x4c, 0xba, 0x56,
|
||||
0xce, 0xaf, 0x73, 0x23, 0xae, 0xb5, 0xd7, 0xe6, 0x7e, 0xad, 0x54, 0x72, 0x9d, 0x9d, 0xaf, 0x7d,
|
||||
0x31, 0xdb, 0x9a, 0x2f, 0x2f, 0x57, 0x1a, 0x96, 0xe9, 0xba, 0x57, 0xcf, 0xb7, 0x9f, 0x4b, 0x7f,
|
||||
0xdd, 0x5f, 0xaf, 0xff, 0x19, 0xe5, 0xb2, 0x2f, 0x5f, 0xbc, 0xd8, 0x7d, 0x15, 0xed, 0xc7, 0x96,
|
||||
0x6b, 0x4f, 0x94, 0xcc, 0x3e, 0x58, 0x9e, 0x15, 0x9f, 0x07, 0x2a, 0x9a, 0x57, 0xbf, 0x1b, 0x9e,
|
||||
0xad, 0xdb, 0x6d, 0x1a, 0xac, 0x7c, 0xb8, 0x9d, 0x2f, 0x75, 0xde, 0x89, 0x89, 0xb4, 0xe5, 0xb2,
|
||||
0x95, 0xd8, 0xe5, 0x07, 0xb1, 0x8e, 0x92, 0xda, 0xea, 0x70, 0x98, 0xff, 0xca, 0xd5, 0x1d, 0xdf,
|
||||
0xcb, 0x3b, 0x78, 0x9f, 0xb7, 0xaa, 0x2d, 0x96, 0x80, 0x66, 0x65, 0xb4, 0x5b, 0xbf, 0x6f, 0xcf,
|
||||
0x42, 0xe7, 0xec, 0x67, 0xd4, 0x28, 0xe5, 0xa7, 0x43, 0xb9, 0xdf, 0x46, 0x36, 0x1a, 0x1a, 0x36,
|
||||
0xeb, 0xcd, 0xd5, 0x96, 0xec, 0xb9, 0xf3, 0xbd, 0x5c, 0x62, 0xb1, 0xbb, 0xdd, 0xfa, 0x6d, 0x1a,
|
||||
0x29, 0x3e, 0xf2, 0x01, 0x09, 0xd8, 0x57, 0xfa, 0xb8, 0xaa, 0x5d, 0x9f, 0x45, 0xd1, 0xd8, 0xd4,
|
||||
0xf8, 0x91, 0xb8, 0x0d, 0xbf, 0xa9, 0x31, 0xdc, 0xc2, 0x7d, 0x99, 0x1e, 0xb4, 0xbb, 0x6d, 0x4e,
|
||||
0xba, 0xcc, 0x24, 0x11, 0x3b, 0x84, 0xde, 0x11, 0x7f, 0x94, 0x7c, 0x6b, 0xd4, 0x88, 0x75, 0xca,
|
||||
0xa5, 0x99, 0xe8, 0x72, 0x71, 0x5c, 0xcb, 0x4f, 0x6f, 0x77, 0x94, 0xe9, 0xc2, 0x35, 0x91, 0x9b,
|
||||
0xbc, 0xae, 0x07, 0x47, 0xbd, 0x45, 0xe1, 0x1e, 0x19, 0xaf, 0x43, 0xaf, 0xa4, 0xbe, 0xd3, 0xf3,
|
||||
0x12, 0xef, 0x45, 0x2a, 0x61, 0x08, 0x9e, 0x45, 0xeb, 0x54, 0x7c, 0xb7, 0x32, 0x9d, 0xae, 0xf7,
|
||||
0xee, 0xb6, 0x34, 0xaa, 0x06, 0x4a, 0x1d, 0x30, 0xc5, 0x45, 0xb1, 0xb5, 0xec, 0x1c, 0x6e, 0xdb,
|
||||
0xbe, 0x94, 0xde, 0xe2, 0x1c, 0x2d, 0xad, 0x9b, 0x4b, 0x7b, 0xd5, 0xe5, 0x2e, 0xd4, 0x4f, 0xe7,
|
||||
0x13, 0x31, 0xf5, 0xaf, 0x4d, 0x3f, 0x11, 0x2c, 0x1d, 0x07, 0x2d, 0x30, 0xee, 0x7e, 0xa9, 0x17,
|
||||
0x98, 0x24, 0xef, 0xdd, 0x2c, 0xb4, 0xd8, 0xfc, 0x7d, 0xe9, 0x67, 0x8e, 0x93, 0x25, 0xaa, 0xe5,
|
||||
0x73, 0x1d, 0x5c, 0x3c, 0x5a, 0x1f, 0xa6, 0xb0, 0xec, 0xa5, 0x59, 0xac, 0x14, 0x43, 0xb3, 0xc2,
|
||||
0xba, 0x65, 0xba, 0x56, 0x29, 0x2e, 0xbb, 0x67, 0x62, 0xc6, 0x78, 0xb4, 0x7a, 0x9f, 0xdc, 0x2a,
|
||||
0xd5, 0xec, 0xaf, 0x49, 0xf7, 0x37, 0x78, 0xe4, 0x3b, 0x85, 0x40, 0xf3, 0x77, 0x71, 0x94, 0x18,
|
||||
0x0f, 0x56, 0x69, 0x2b, 0xac, 0x7e, 0xed, 0x39, 0x3f, 0xac, 0xce, 0x01, 0x0d, 0xc3, 0xcf, 0x27,
|
||||
0x75, 0x0f, 0x44, 0xab, 0x21, 0x49, 0xcc, 0xe9, 0x3c, 0xb7, 0x59, 0xd6, 0x43, 0xe7, 0xc6, 0xd8,
|
||||
0xcb, 0x36, 0xfc, 0xaf, 0xf7, 0xff, 0xd5, 0xb2, 0x91, 0xf5, 0x2d, 0x32, 0x8a, 0x66, 0x8e, 0x5b,
|
||||
0xc3, 0xeb, 0x5c, 0x7b, 0x32, 0xfd, 0x85, 0x7a, 0xd3, 0x87, 0xb2, 0x71, 0xe8, 0x1c, 0xde, 0xcd,
|
||||
0x13, 0x85, 0x75, 0x84, 0x64, 0xe6, 0x99, 0xee, 0x8d, 0xa2, 0x45, 0x07, 0xa3, 0x7f, 0xfa, 0x94,
|
||||
0xc9, 0x77, 0xa7, 0x87, 0x9f, 0xa7, 0xfe, 0xbd, 0x34, 0xcf, 0x55, 0x5a, 0xb5, 0x8e, 0xd8, 0x56,
|
||||
0xf7, 0x17, 0x08, 0xee, 0x6a, 0xb9, 0x8b, 0xb5, 0x74, 0xf5, 0xf8, 0x49, 0x07, 0x1b, 0x05, 0x93,
|
||||
0xdf, 0xe9, 0x23, 0x98, 0x5d, 0x6d, 0x4e, 0x73, 0x0d, 0xc3, 0xd8, 0xbc, 0x73, 0xe9, 0x7f, 0x22,
|
||||
0x77, 0x15, 0xf6, 0xc3, 0x60, 0x57, 0x6b, 0x7e, 0x1a, 0x49, 0x8f, 0x90, 0x75, 0xf0, 0xf2, 0x8d,
|
||||
0xa6, 0x9e, 0x89, 0x4f, 0xad, 0x42, 0xee, 0x3a, 0x59, 0x46, 0x52, 0x7b, 0x66, 0xb8, 0xc8, 0xb7,
|
||||
0xf4, 0xef, 0xcc, 0xb6, 0x05, 0xfd, 0xbb, 0x51, 0x63, 0x3f, 0x98, 0x3f, 0x43, 0x4f, 0x80, 0x99,
|
||||
0xf6, 0x69, 0xdc, 0xba, 0x0d, 0x77, 0xe1, 0x51, 0xe4, 0x72, 0x6e, 0x9e, 0x1a, 0x3e, 0x96, 0x03,
|
||||
0x64, 0xa8, 0xc7, 0x35, 0x9e, 0xea, 0x44, 0xb6, 0xb9, 0x60, 0x8b, 0xd9, 0x30, 0xd0, 0xa8, 0x67,
|
||||
0x26, 0x7d, 0xf6, 0xaa, 0x6c, 0xb3, 0xbb, 0xbd, 0x87, 0x4a, 0x53, 0x27, 0xe2, 0x40, 0x77, 0xf0,
|
||||
0xed, 0x6e, 0x8b, 0xb5, 0xd9, 0xab, 0xcd, 0x70, 0x10, 0x19, 0xc5, 0x9b, 0x2f, 0xdf, 0x95, 0x62,
|
||||
0x35, 0xde, 0xd9, 0x8c, 0x67, 0x39, 0x43, 0xca, 0xfb, 0x24, 0x59, 0xed, 0x05, 0xee, 0x7b, 0xf3,
|
||||
0xc0, 0x56, 0xaa, 0x34, 0x7d, 0xbd, 0xb3, 0x27, 0x75, 0x8e, 0x72, 0x36, 0xbe, 0x3a, 0xe5, 0xb2,
|
||||
0x03, 0x6e, 0x81, 0xf1, 0x20, 0xb8, 0xb9, 0x07, 0x37, 0xc7, 0x99, 0xdd, 0x50, 0x31, 0xb5, 0x28,
|
||||
0x7e, 0xf7, 0xd1, 0x87, 0x89, 0xdd, 0xee, 0xb3, 0xfd, 0x6c, 0xa3, 0xe1, 0x1e, 0xc7, 0x41, 0x69,
|
||||
0x10, 0x4f, 0xec, 0x9f, 0x47, 0xcf, 0xbb, 0xde, 0xfb, 0xb2, 0x38, 0xbf, 0x22, 0x6f, 0xd5, 0xac,
|
||||
0x45, 0xf3, 0x10, 0x4a, 0xcc, 0xdb, 0x79, 0x40, 0xe8, 0x63, 0xfd, 0xb0, 0x4a, 0xce, 0x3a, 0x37,
|
||||
0x3b, 0xa8, 0x75, 0x78, 0x9a, 0x4f, 0x0c, 0x83, 0xf1, 0x3a, 0x8d, 0x60, 0xe5, 0xba, 0x8b, 0xdd,
|
||||
0x32, 0x4f, 0xa2, 0x9f, 0xe2, 0x2d, 0xdd, 0xa9, 0x0c, 0x6a, 0x73, 0x21, 0xf6, 0xf1, 0x73, 0x51,
|
||||
0x3a, 0x35, 0x76, 0xad, 0x48, 0xd4, 0xfa, 0x67, 0x17, 0x48, 0xf7, 0xfb, 0x35, 0x8d, 0xfd, 0x51,
|
||||
0xfe, 0xdf, 0x2c, 0x2e, 0x72, 0xf1, 0x4c, 0xcc, 0x79, 0x2a, 0x78, 0x5f, 0xf5, 0xa7, 0xc7, 0x8d,
|
||||
0x8f, 0xe9, 0xe4, 0xbe, 0x0a, 0x87, 0x7e, 0x75, 0xfc, 0xf2, 0xf9, 0x26, 0x1e, 0x78, 0xef, 0xf2,
|
||||
0x69, 0x2e, 0xf2, 0xee, 0xbf, 0x5c, 0x6b, 0x16, 0xf7, 0x5d, 0x14, 0xe4, 0x55, 0xf6, 0x3b, 0x8b,
|
||||
0x57, 0xdb, 0xc7, 0x7e, 0xc1, 0x7b, 0x7b, 0x7f, 0x49, 0xc4, 0xf2, 0xa9, 0x0a, 0x89, 0xe6, 0xa6,
|
||||
0xb5, 0xaa, 0xbd, 0xbf, 0xc1, 0x36, 0xa3, 0xe7, 0x29, 0x78, 0x4f, 0x0f, 0x22, 0xa5, 0xb9, 0xaa,
|
||||
0xd7, 0x3f, 0x56, 0xbc, 0x04, 0x77, 0x97, 0x2b, 0xf0, 0x45, 0xe1, 0xf7, 0x9c, 0x3f, 0xee, 0x7b,
|
||||
0xa0, 0xea, 0x73, 0x3d, 0x31, 0xca, 0x7d, 0x2b, 0x1f, 0x7b, 0xda, 0x48, 0xe3, 0x57, 0x58, 0x77,
|
||||
0xeb, 0x91, 0x20, 0x94, 0x5c, 0xf2, 0xd9, 0xbd, 0x45, 0xce, 0xd5, 0x37, 0xae, 0xf0, 0xa7, 0x3f,
|
||||
0x78, 0x14, 0xdb, 0x17, 0x92, 0x9a, 0xc6, 0x6d, 0xd0, 0xf8, 0x9c, 0xfe, 0x39, 0xe3, 0xb5, 0x63,
|
||||
0xbd, 0x94, 0xd9, 0x36, 0x97, 0x79, 0xed, 0xe6, 0xe2, 0xf9, 0x99, 0x5f, 0x17, 0x92, 0xe1, 0x74,
|
||||
0xce, 0x4a, 0x6f, 0x18, 0x0a, 0x06, 0x56, 0x15, 0x23, 0x91, 0x46, 0x73, 0x17, 0xea, 0xb5, 0xc3,
|
||||
0xd1, 0x12, 0xae, 0xd8, 0x2f, 0xba, 0xbb, 0x8c, 0x2a, 0x03, 0x81, 0xb2, 0x6b, 0xa9, 0x3f, 0xca,
|
||||
0xf7, 0xf3, 0x99, 0xc1, 0xdc, 0x5c, 0x69, 0x34, 0xd9, 0xf7, 0x6b, 0x97, 0x24, 0xc9, 0xd2, 0x3e,
|
||||
0xf9, 0xfd, 0x67, 0xd7, 0x6d, 0xbf, 0xb7, 0x7e, 0xad, 0x5f, 0xb9, 0x76, 0x2b, 0xdb, 0xcb, 0xa7,
|
||||
0xc5, 0xb5, 0x13, 0x2e, 0x6e, 0xfa, 0x6b, 0xe0, 0xfe, 0xea, 0xf5, 0x1f, 0x4a, 0xc7, 0xc6, 0xe9,
|
||||
0xd6, 0x83, 0x71, 0x75, 0xfa, 0xef, 0x5c, 0xdf, 0x95, 0xa3, 0x8f, 0x41, 0x77, 0xd2, 0xef, 0xa7,
|
||||
0xbe, 0xfb, 0x24, 0xb5, 0xe6, 0x6f, 0x30, 0x0e, 0x86, 0xde, 0x9f, 0x95, 0xd5, 0xe6, 0x6e, 0xf4,
|
||||
0x88, 0xa6, 0x77, 0x11, 0x36, 0x8b, 0xf1, 0xba, 0x1a, 0x9c, 0xe4, 0xaf, 0xcb, 0xc6, 0x87, 0xd6,
|
||||
0x33, 0x1a, 0x9f, 0xbd, 0x0e, 0x5f, 0x19, 0x85, 0xdc, 0x6e, 0xd0, 0x08, 0xe6, 0xba, 0xf5, 0x40,
|
||||
0x8d, 0xc7, 0x36, 0xb5, 0xbe, 0x8e, 0xd6, 0xe7, 0x6e, 0x94, 0xcd, 0x30, 0x99, 0x2d, 0x14, 0xe6,
|
||||
0x21, 0x62, 0xfe, 0xe5, 0x76, 0xd3, 0xdb, 0xa4, 0xde, 0xe5, 0xc3, 0xe4, 0xd7, 0xaa, 0x16, 0x99,
|
||||
0x4c, 0x6b, 0xbf, 0x62, 0xb9, 0xf4, 0xf5, 0x3d, 0x5f, 0xb4, 0x23, 0x3b, 0x68, 0xa4, 0xcf, 0xe6,
|
||||
0x98, 0x08, 0xee, 0x0a, 0x55, 0x73, 0x9e, 0xc2, 0x2d, 0x17, 0x2e, 0x4c, 0x56, 0xdb, 0xe0, 0x92,
|
||||
0x6d, 0x78, 0xdb, 0xce, 0x97, 0x2f, 0x05, 0x6d, 0xa3, 0x5a, 0xae, 0xde, 0x2a, 0x9f, 0x0e, 0x49,
|
||||
0x96, 0x98, 0x40, 0x74, 0x18, 0x28, 0x95, 0x1b, 0x9f, 0xe0, 0xb2, 0x49, 0x63, 0x91, 0xb8, 0x86,
|
||||
0xe7, 0x8f, 0x8b, 0x84, 0xec, 0x75, 0x53, 0xbb, 0x6f, 0xbf, 0x6b, 0x41, 0xe3, 0xec, 0x6f, 0x72,
|
||||
0x4f, 0xff, 0x6f, 0xbb, 0x8e, 0x9a, 0x76, 0x65, 0x51, 0xda, 0x5c, 0xd7, 0x7d, 0xdc, 0x96, 0x49,
|
||||
0x21, 0x74, 0xeb, 0x7d, 0xe3, 0x37, 0x34, 0xe7, 0x71, 0xb4, 0xbb, 0x6d, 0x2c, 0x86, 0x57, 0x07,
|
||||
0xeb, 0xcb, 0x35, 0x9e, 0xfb, 0xd5, 0x6e, 0xe5, 0xca, 0xa8, 0x52, 0x2b, 0xd4, 0xae, 0xee, 0x23,
|
||||
0xbd, 0xa2, 0x89, 0xdd, 0x7f, 0xd6, 0x4a, 0x9e, 0x3b, 0xbd, 0x3a, 0xbc, 0x5a, 0x3c, 0xdc, 0xce,
|
||||
0xa7, 0x3f, 0x21, 0xf5, 0xd1, 0xe4, 0x31, 0xbb, 0x0a, 0x67, 0xab, 0xa1, 0xef, 0xa3, 0x7d, 0xf1,
|
||||
0x73, 0xf8, 0xf7, 0xc6, 0xaf, 0x49, 0xe5, 0xed, 0x2a, 0x11, 0xa9, 0x1c, 0xaf, 0x67, 0x77, 0xf5,
|
||||
0xed, 0x71, 0x55, 0x6c, 0xbe, 0xff, 0x41, 0xe9, 0xb6, 0x61, 0xeb, 0xb9, 0xae, 0x6e, 0xae, 0xf5,
|
||||
0x58, 0x90, 0x49, 0xa6, 0x79, 0xad, 0x25, 0x9b, 0xdd, 0x77, 0xd1, 0x45, 0xfb, 0x18, 0x6a, 0xf6,
|
||||
0x76, 0xb9, 0x7e, 0xd1, 0xff, 0x37, 0x7f, 0x0c, 0x16, 0x56, 0xd7, 0x5f, 0x91, 0xfe, 0x26, 0xb9,
|
||||
0x59, 0x37, 0x06, 0x01, 0xcb, 0xad, 0xd8, 0xf3, 0x79, 0x4e, 0x84, 0x53, 0xfb, 0xea, 0xc4, 0xfa,
|
||||
0x7d, 0x34, 0x2f, 0x17, 0x77, 0x35, 0xee, 0xa9, 0xcc, 0x2e, 0x58, 0xc8, 0xd7, 0x6a, 0xc7, 0x05,
|
||||
0x95, 0x71, 0x72, 0x73, 0xee, 0x45, 0xb6, 0xed, 0x96, 0x9a, 0xe0, 0x23, 0x35, 0x1a, 0x4d, 0x02,
|
||||
0xed, 0x57, 0xc4, 0x49, 0x34, 0x54, 0xee, 0xfe, 0x22, 0x97, 0xb1, 0xea, 0x4c, 0xb5, 0x5b, 0x8b,
|
||||
0x0e, 0x96, 0x47, 0xf4, 0xb1, 0x59, 0x77, 0x10, 0x8f, 0x4d, 0xb6, 0xf5, 0x08, 0xbc, 0xf9, 0x72,
|
||||
0x54, 0x38, 0x27, 0xd3, 0x3f, 0xd3, 0xbb, 0xf9, 0xe6, 0xf4, 0xff, 0x1e, 0x3a, 0x3f, 0x28, 0x92,
|
||||
0x6c, 0x74, 0x78, 0x8a, 0x6d, 0xee, 0x13, 0x80, 0xa1, 0xd4, 0x60, 0xf4, 0x7e, 0xdc, 0x72, 0xad,
|
||||
0xe9, 0xcd, 0x46, 0x61, 0x1a, 0x9b, 0xb7, 0xf7, 0x61, 0x82, 0xc3, 0x5f, 0xb6, 0xd0, 0x7a, 0xde,
|
||||
0x9f, 0xbd, 0x0e, 0xf8, 0x77, 0xe6, 0x92, 0xce, 0x07, 0x26, 0xf7, 0x59, 0x86, 0xc9, 0xfc, 0xf3,
|
||||
0xce, 0x3e, 0x4a, 0xcf, 0x1c, 0xa5, 0x6e, 0x74, 0x34, 0x1d, 0xf4, 0x9e, 0x89, 0x51, 0x86, 0x7e,
|
||||
0x6a, 0x5b, 0xcb, 0x3c, 0x8a, 0x3b, 0x92, 0x8b, 0xc2, 0xa7, 0x75, 0x4c, 0x97, 0x7e, 0xe7, 0x9e,
|
||||
0xca, 0x5c, 0x6d, 0xf4, 0xd8, 0xff, 0x96, 0x5b, 0xe8, 0xa8, 0x5b, 0xbf, 0x1d, 0xab, 0xb4, 0x9f,
|
||||
0x4b, 0x10, 0xaf, 0xeb, 0xf0, 0xd5, 0x5d, 0xfd, 0x52, 0x3f, 0x7b, 0xe6, 0xe5, 0x7c, 0x51, 0x7a,
|
||||
0xc7, 0x43, 0xcd, 0x35, 0xfa, 0xc2, 0x79, 0xf3, 0xeb, 0xde, 0xba, 0xed, 0x2e, 0xeb, 0x75, 0x7c,
|
||||
0xd1, 0x3d, 0x77, 0x0b, 0xa3, 0xc9, 0x95, 0xe9, 0x22, 0x70, 0x5c, 0x4d, 0x76, 0xff, 0xde, 0x9b,
|
||||
0x77, 0xe9, 0xb0, 0x9c, 0xce, 0x87, 0x1f, 0x4e, 0x94, 0x67, 0xbe, 0xbb, 0x1a, 0xe7, 0x97, 0x6d,
|
||||
0xd1, 0xd0, 0xc5, 0x3a, 0x37, 0xdb, 0x96, 0xaa, 0x05, 0x22, 0x94, 0xc6, 0xbe, 0xb5, 0x78, 0xb4,
|
||||
0xd7, 0xb3, 0x6f, 0x90, 0x58, 0xbc, 0x9d, 0xfc, 0xe5, 0x3e, 0xd3, 0x25, 0x98, 0xf3, 0x7b, 0x18,
|
||||
0xda, 0x27, 0x2f, 0xa7, 0x5b, 0xc2, 0xc3, 0x75, 0xb5, 0x9b, 0xb4, 0x3e, 0x49, 0xfc, 0xe4, 0xe3,
|
||||
0x2f, 0x93, 0xe9, 0x1f, 0x9f, 0x91, 0x03, 0xc6, 0x7a, 0x25, 0x19, 0xef, 0x4f, 0x7f, 0xe9, 0x64,
|
||||
0x9e, 0xd0, 0x2e, 0x18, 0x5f, 0x64, 0xb2, 0x99, 0x89, 0xc7, 0x5d, 0xa0, 0xda, 0xdb, 0x4c, 0x4f,
|
||||
0xbd, 0xd8, 0x86, 0x61, 0xf2, 0x78, 0x49, 0x87, 0x7e, 0xbf, 0xbb, 0xad, 0x7d, 0x37, 0x33, 0x2c,
|
||||
0x07, 0x33, 0x5f, 0xa7, 0xbf, 0x6f, 0x2a, 0xfd, 0xfb, 0xdc, 0x63, 0x19, 0xb3, 0x80, 0x6d, 0x2a,
|
||||
0xd6, 0xdd, 0x47, 0x9f, 0xe9, 0x0f, 0xfc, 0x4e, 0xf7, 0x54, 0x7a, 0xf4, 0xee, 0x4f, 0xba, 0xdb,
|
||||
0x4d, 0xee, 0xb5, 0xb9, 0x5f, 0x62, 0x33, 0xcc, 0x8f, 0x44, 0x68, 0xd0, 0xc8, 0x87, 0xc6, 0xb7,
|
||||
0x34, 0xdc, 0x72, 0x62, 0xb7, 0x28, 0x2d, 0xae, 0xd5, 0x16, 0xc3, 0xf5, 0xbb, 0x53, 0xaa, 0xb5,
|
||||
0xba, 0x07, 0xc5, 0x88, 0xd4, 0xae, 0xd1, 0x3d, 0xec, 0x3f, 0xe9, 0x63, 0xff, 0x5e, 0xa3, 0x32,
|
||||
0x3b, 0x2d, 0xdb, 0x27, 0x2e, 0xa3, 0xfc, 0xbb, 0xb0, 0xde, 0x47, 0xdb, 0x2d, 0x49, 0x89, 0x50,
|
||||
0xba, 0x35, 0xfb, 0x5c, 0x6b, 0x0b, 0x7c, 0x9f, 0x4e, 0x7e, 0x5d, 0x0b, 0xdc, 0x92, 0x2d, 0x87,
|
||||
0xfe, 0xea, 0x3a, 0x93, 0xc9, 0x27, 0x56, 0x75, 0x0b, 0x97, 0x50, 0xf1, 0x3d, 0xce, 0x0e, 0x5f,
|
||||
0xc9, 0xc6, 0xc7, 0x65, 0x72, 0xd8, 0xfe, 0xe4, 0x47, 0x77, 0xb3, 0xf8, 0xea, 0x3e, 0xd6, 0xcc,
|
||||
0x0e, 0x43, 0x57, 0xd1, 0xf3, 0xc3, 0x6e, 0xf8, 0x9b, 0x1c, 0x67, 0x01, 0xfa, 0xba, 0x5c, 0x7a,
|
||||
0xd4, 0x7e, 0xe6, 0xa6, 0xbf, 0x6a, 0xb7, 0x78, 0xad, 0x1a, 0x89, 0x16, 0x57, 0xff, 0x15, 0xdc,
|
||||
0x4e, 0xf3, 0x58, 0xbb, 0x77, 0x4e, 0xc3, 0x24, 0xdb, 0x6b, 0x67, 0xb4, 0xb9, 0x05, 0xe2, 0x0d,
|
||||
0xab, 0xda, 0x44, 0xfc, 0x16, 0x8d, 0xed, 0xe3, 0x39, 0xb8, 0xb6, 0x75, 0xff, 0xd2, 0xcb, 0x7f,
|
||||
0xfa, 0xd3, 0x9c, 0xc3, 0xfb, 0x29, 0x37, 0x8a, 0x24, 0xab, 0xfd, 0x0a, 0x89, 0xc6, 0x22, 0x52,
|
||||
0xf8, 0x54, 0x62, 0xa9, 0x36, 0xdc, 0xfb, 0xe5, 0x3f, 0xca, 0xcf, 0xb2, 0x7b, 0x29, 0x95, 0x58,
|
||||
0x2a, 0xb4, 0x78, 0xed, 0x03, 0x01, 0x33, 0xc6, 0x49, 0xaf, 0xd2, 0x79, 0x4f, 0xfe, 0x0d, 0x3f,
|
||||
0xc9, 0xf2, 0xf6, 0x9c, 0xec, 0x27, 0x93, 0x73, 0xea, 0xff, 0x69, 0x64, 0xda, 0x5c, 0x5f, 0xc3,
|
||||
0xb1, 0xba, 0xb2, 0x48, 0xab, 0x7f, 0xa8, 0x54, 0x17, 0x89, 0x51, 0xa7, 0xe6, 0x78, 0x99, 0x69,
|
||||
0x77, 0x66, 0x9d, 0xe0, 0xb0, 0xec, 0xf9, 0x34, 0xcd, 0xaf, 0xba, 0xa5, 0x15, 0xd6, 0xec, 0x74,
|
||||
0x3e, 0x89, 0x17, 0x0f, 0x87, 0x85, 0xfd, 0x6e, 0xa0, 0x18, 0x69, 0x3f, 0x7a, 0x23, 0x22, 0xf6,
|
||||
0x58, 0xf7, 0x5d, 0xdc, 0x2c, 0x2e, 0x99, 0x42, 0x80, 0xc5, 0xb0, 0x14, 0x39, 0x9d, 0x8b, 0x8d,
|
||||
0x8e, 0xb6, 0xd7, 0xe1, 0xf2, 0xdc, 0x4e, 0x57, 0xbd, 0x17, 0x81, 0x4d, 0x6f, 0x98, 0x2a, 0x6d,
|
||||
0x2a, 0x33, 0x15, 0xcf, 0xe8, 0xa6, 0x57, 0xf9, 0x76, 0xa2, 0x67, 0x82, 0xce, 0xd8, 0xaf, 0xd4,
|
||||
0x89, 0x65, 0x76, 0x75, 0x14, 0xf1, 0xd1, 0xbf, 0x56, 0xf8, 0xa5, 0xbe, 0x97, 0xbc, 0x96, 0xdc,
|
||||
0x2e, 0x9a, 0xe9, 0xbc, 0x4f, 0xc1, 0x63, 0xa4, 0x43, 0x34, 0x32, 0xca, 0xed, 0xfe, 0x97, 0xa8,
|
||||
0xcc, 0x40, 0xf4, 0xdf, 0x1d, 0xbe, 0x1a, 0x39, 0x31, 0xfc, 0x50, 0x7a, 0x1d, 0xcf, 0xce, 0x3a,
|
||||
0xb3, 0xa8, 0xa3, 0xfe, 0x2c, 0xdb, 0xed, 0x65, 0xdb, 0x41, 0x52, 0x8b, 0xfa, 0x65, 0x7c, 0x8d,
|
||||
0x8e, 0x7e, 0xeb, 0xca, 0xe7, 0x6b, 0xf5, 0x7e, 0x8a, 0x5c, 0xdb, 0xb1, 0x82, 0xc7, 0xdc, 0xb1,
|
||||
0xd1, 0x5a, 0x5e, 0x72, 0xc3, 0x4a, 0x90, 0x58, 0xe2, 0xf4, 0xae, 0x55, 0x06, 0x85, 0xc0, 0xd4,
|
||||
0xea, 0x23, 0x30, 0xca, 0x1e, 0x3a, 0x7f, 0x5a, 0xfd, 0x57, 0x66, 0x30, 0x5e, 0x35, 0x63, 0x0d,
|
||||
0x6a, 0xbf, 0xe8, 0x68, 0x35, 0xfa, 0x24, 0xa2, 0xdf, 0x46, 0xac, 0x4d, 0xac, 0x5c, 0x08, 0x1f,
|
||||
0x0a, 0xdf, 0xee, 0xfa, 0x72, 0xe4, 0x56, 0xaa, 0xdc, 0xce, 0xeb, 0xf5, 0xd0, 0xd9, 0x3f, 0xf0,
|
||||
0x0b, 0x8c, 0xdf, 0xb9, 0x9b, 0xa6, 0x72, 0xac, 0x9c, 0xae, 0xd4, 0x32, 0x4b, 0xbf, 0xe1, 0x41,
|
||||
0x20, 0x10, 0x0c, 0x44, 0x3a, 0xfb, 0xa1, 0xe5, 0xce, 0x30, 0xd1, 0xb8, 0x4c, 0xd2, 0xcb, 0x10,
|
||||
0xa5, 0xd0, 0x7f, 0xd0, 0x3f, 0xaf, 0x82, 0xd1, 0x88, 0xef, 0xf5, 0xb6, 0x1a, 0x48, 0x77, 0xa3,
|
||||
0xd9, 0xf1, 0xa9, 0xe6, 0x3c, 0xd7, 0xea, 0x57, 0xd3, 0xc9, 0x45, 0x95, 0xe7, 0xf3, 0x16, 0x19,
|
||||
0xef, 0x16, 0xb9, 0x32, 0xab, 0x46, 0x65, 0xf9, 0x1e, 0xa4, 0x46, 0x43, 0x53, 0xca, 0x7c, 0xbb,
|
||||
0xdb, 0x18, 0x0c, 0x83, 0xb1, 0x92, 0x92, 0x5e, 0xf8, 0xbc, 0x9d, 0x65, 0x1a, 0xe9, 0xee, 0xd0,
|
||||
0x74, 0xfc, 0x7c, 0xfa, 0xcc, 0x56, 0x77, 0xb0, 0xa9, 0x6c, 0x3d, 0x90, 0xcc, 0x4c, 0x5f, 0xd3,
|
||||
0x63, 0x8f, 0x6c, 0x29, 0x1c, 0x3e, 0x96, 0x3a, 0xc9, 0xd1, 0xe3, 0x40, 0xea, 0x11, 0x5c, 0x4d,
|
||||
0x6e, 0x8b, 0xa0, 0xe3, 0x50, 0x67, 0x32, 0x1e, 0xbf, 0x07, 0xb9, 0x5a, 0x95, 0x57, 0xba, 0xdc,
|
||||
0xc9, 0x9d, 0xde, 0x0f, 0x7d, 0xe9, 0xe1, 0x75, 0xb8, 0xbf, 0x94, 0x32, 0xdf, 0x0c, 0xa2, 0x6c,
|
||||
0xe6, 0x3e, 0x69, 0x87, 0x63, 0x03, 0xb9, 0xb1, 0xf5, 0x33, 0xfb, 0xde, 0x47, 0x5a, 0x81, 0x8d,
|
||||
0xa3, 0xde, 0x29, 0xf8, 0xa8, 0x95, 0x56, 0x7b, 0x31, 0xef, 0xc7, 0xba, 0xdd, 0x78, 0xee, 0x8f,
|
||||
0x1f, 0xc9, 0x93, 0x78, 0x22, 0x35, 0x99, 0x26, 0x9a, 0xe5, 0x9d, 0xfb, 0x72, 0x37, 0x9c, 0x1f,
|
||||
0x84, 0xeb, 0x35, 0x81, 0x84, 0x30, 0xb8, 0x05, 0x58, 0x8e, 0xed, 0x7a, 0x72, 0x0c, 0x06, 0x1f,
|
||||
0x7d, 0x36, 0xeb, 0xfa, 0xfe, 0xf5, 0xcf, 0x74, 0x9a, 0x3f, 0x2f, 0x83, 0xc3, 0x35, 0x19, 0xa9,
|
||||
0xe6, 0xd3, 0xef, 0x18, 0xb6, 0x63, 0x24, 0x9d, 0xe9, 0x54, 0x2b, 0x17, 0x34, 0xe7, 0x44, 0x75,
|
||||
0xd8, 0xae, 0xc5, 0x27, 0xeb, 0x64, 0xbe, 0xd2, 0x79, 0x79, 0x5b, 0x15, 0xc7, 0xa9, 0x55, 0xb3,
|
||||
0xe2, 0xa9, 0xff, 0xee, 0xd7, 0x76, 0xed, 0x68, 0xb1, 0xe5, 0xaa, 0x76, 0x0c, 0x76, 0x86, 0x5b,
|
||||
0x23, 0xe7, 0xd3, 0x29, 0x91, 0xef, 0x2e, 0x52, 0xd7, 0x91, 0xdb, 0xda, 0x7c, 0xde, 0xef, 0x7f,
|
||||
0x5b, 0x77, 0x53, 0xf3, 0x45, 0x6b, 0x5d, 0xae, 0x56, 0xa7, 0xdb, 0xc0, 0xd0, 0x55, 0x6c, 0x77,
|
||||
0x1c, 0x9e, 0x52, 0x81, 0xd4, 0xe9, 0xe0, 0x2e, 0x53, 0x99, 0x25, 0xab, 0x27, 0x91, 0xba, 0x55,
|
||||
0x79, 0xb4, 0x7a, 0xee, 0xda, 0xf5, 0xb2, 0xa7, 0xc9, 0xf5, 0xbd, 0x69, 0xfd, 0xaf, 0xbd, 0x88,
|
||||
0xab, 0x43, 0x79, 0x92, 0x18, 0xbc, 0xa7, 0x7f, 0x2a, 0xea, 0xf4, 0x3f, 0xbe, 0xfa, 0x15, 0xfe,
|
||||
0x2d, 0x7c, 0xd0, 0xfe, 0x30, 0xbe, 0x0e, 0x7f, 0x97, 0x9d, 0x4c, 0xfb, 0x69, 0x6c, 0xf1, 0x7c,
|
||||
0x27, 0xbb, 0x3d, 0xee, 0xf2, 0x61, 0xbc, 0xf9, 0x0e, 0x25, 0x27, 0x89, 0x78, 0x83, 0x45, 0xfc,
|
||||
0x5e, 0x4d, 0x74, 0xde, 0x09, 0xce, 0xe3, 0x79, 0xf4, 0xf9, 0x7e, 0xad, 0xde, 0x8d, 0x72, 0xed,
|
||||
0x52, 0x76, 0xb3, 0x5f, 0x86, 0xf2, 0xc9, 0x56, 0xc4, 0x70, 0x24, 0xb2, 0x5f, 0x8f, 0xe6, 0xcf,
|
||||
0x5b, 0xaa, 0x5f, 0xad, 0x7d, 0xc9, 0xc5, 0xf3, 0xe3, 0x02, 0x99, 0xe4, 0x62, 0x3a, 0xb9, 0x9e,
|
||||
0x3e, 0x5d, 0x7d, 0xe7, 0xcd, 0xeb, 0x39, 0x5d, 0xb5, 0x6b, 0x21, 0x5d, 0xfa, 0xfa, 0x69, 0x7c,
|
||||
0x3b, 0xc6, 0xfb, 0x51, 0x37, 0xb8, 0x5b, 0xf7, 0xfc, 0x4f, 0x0d, 0x03, 0x35, 0x64, 0xa0, 0x7e,
|
||||
0xf9, 0xba, 0x1c, 0x34, 0x3a, 0xa1, 0x41, 0xce, 0x49, 0xbd, 0x7c, 0xb9, 0xee, 0x73, 0x9b, 0x18,
|
||||
0xe9, 0xfc, 0x6f, 0x97, 0xea, 0x76, 0x1e, 0xfd, 0xce, 0xd3, 0xd5, 0xeb, 0x7d, 0x3b, 0x4f, 0x33,
|
||||
0x89, 0xc9, 0xec, 0xcb, 0xf7, 0xfe, 0x99, 0xa4, 0x8e, 0x15, 0xe6, 0xb5, 0x70, 0xb9, 0xb0, 0x9b,
|
||||
0xcd, 0x8b, 0x03, 0xa4, 0xcc, 0xcf, 0xfd, 0x94, 0x1f, 0x47, 0x12, 0x87, 0xe7, 0xde, 0xfc, 0xfe,
|
||||
0x96, 0x0e, 0x84, 0xc3, 0x45, 0x80, 0xc5, 0x7e, 0xf6, 0x7b, 0x48, 0xc4, 0x73, 0x8d, 0x90, 0xfb,
|
||||
0xc1, 0xbf, 0x39, 0x1d, 0x34, 0xc3, 0x31, 0x21, 0xf9, 0xf8, 0xf4, 0xd8, 0xfc, 0x87, 0xd2, 0x3d,
|
||||
0xb8, 0xa5, 0x70, 0x70, 0xba, 0x0c, 0x75, 0xeb, 0x49, 0x6a, 0xae, 0xc4, 0xf1, 0x1d, 0x99, 0x0e,
|
||||
0x8a, 0x67, 0x99, 0x9d, 0x41, 0xb2, 0x9c, 0x19, 0x5e, 0x1e, 0x63, 0x7f, 0x91, 0xc2, 0x3e, 0x54,
|
||||
0x88, 0x54, 0x2b, 0x13, 0x4c, 0xd4, 0x52, 0x23, 0xdc, 0x18, 0x9f, 0xb6, 0xbd, 0xdf, 0xca, 0x5c,
|
||||
0x7a, 0xb6, 0x3d, 0x3c, 0xae, 0x29, 0x92, 0xd7, 0xc4, 0x34, 0x37, 0xec, 0x2c, 0x96, 0x0b, 0x9a,
|
||||
0x94, 0x4f, 0xe2, 0xf1, 0x2a, 0xef, 0x26, 0x77, 0xef, 0xb7, 0x41, 0x62, 0xfb, 0x1c, 0xff, 0xfa,
|
||||
0x87, 0x34, 0xd0, 0xd6, 0xa8, 0x3f, 0x0a, 0x86, 0xdf, 0x7b, 0x3f, 0xc1, 0xe6, 0x2a, 0xfb, 0x9c,
|
||||
0x7f, 0xbf, 0x51, 0x9a, 0xb6, 0xee, 0x74, 0xd7, 0x59, 0x5d, 0x57, 0x7b, 0xc0, 0xf1, 0xfa, 0xb6,
|
||||
0xd4, 0xbc, 0x77, 0x17, 0xa3, 0x6b, 0xd1, 0x75, 0x7b, 0x31, 0x88, 0xd4, 0xeb, 0xc5, 0x2f, 0xd9,
|
||||
0xf8, 0x3f, 0x92, 0x4c, 0x4f, 0xdb, 0xab, 0x94, 0xda, 0x41, 0x71, 0x94, 0x39, 0xee, 0xbf, 0xb9,
|
||||
0x7d, 0xb6, 0xed, 0xa8, 0xb1, 0x2d, 0x9f, 0xba, 0xe3, 0x82, 0xdc, 0xe9, 0xf1, 0xfa, 0x68, 0x56,
|
||||
0x2b, 0x39, 0x21, 0xbf, 0x64, 0xed, 0x9f, 0x8f, 0xf6, 0xaa, 0xfb, 0xf4, 0x91, 0xcc, 0xee, 0xd2,
|
||||
0xdb, 0x2d, 0x72, 0x6b, 0xbb, 0xaa, 0xd6, 0x72, 0x5b, 0xe8, 0x8c, 0xf7, 0x63, 0x8f, 0xb7, 0x5a,
|
||||
0xb0, 0x76, 0xca, 0x4d, 0x5e, 0x69, 0xf0, 0xf3, 0xd3, 0xb8, 0x51, 0x9f, 0xfe, 0x93, 0xd7, 0xd3,
|
||||
0xf5, 0x4f, 0xa5, 0xfb, 0x18, 0xff, 0x66, 0x6f, 0x06, 0xc2, 0x4a, 0x68, 0x79, 0x8a, 0xb5, 0x03,
|
||||
0x95, 0x25, 0xa5, 0x43, 0xbd, 0xfb, 0xff, 0xa7, 0x53, 0x5d, 0x70, 0xf3, 0xcd, 0xea, 0xbe, 0x19,
|
||||
0xce, 0xa3, 0xab, 0xe4, 0xb2, 0xf2, 0xa6, 0xd3, 0x6c, 0xb6, 0x6e, 0xe1, 0x2b, 0xc6, 0x61, 0x24,
|
||||
0xfc, 0x5f, 0x7c, 0x87, 0x29, 0x52, 0x92, 0xf5, 0xe4, 0xd9, 0x7e, 0x0c, 0xd3, 0x7f, 0x53, 0x85,
|
||||
0xfe, 0xb8, 0x73, 0x3b, 0x1f, 0x5b, 0x6f, 0xc4, 0xe2, 0x52, 0xa0, 0x7b, 0xe8, 0x45, 0x0a, 0xd5,
|
||||
0xc6, 0xce, 0x56, 0xb2, 0x3e, 0x89, 0x36, 0x9e, 0x89, 0x37, 0xd7, 0x76, 0xb9, 0x13, 0xda, 0x0f,
|
||||
0xf6, 0x57, 0xf0, 0xfc, 0x76, 0xec, 0xbe, 0x6f, 0xdc, 0x0e, 0x9d, 0x39, 0x8a, 0x79, 0xab, 0x34,
|
||||
0xfe, 0x74, 0x3f, 0x2f, 0x42, 0xbc, 0xe6, 0x29, 0x15, 0x68, 0xb5, 0xc3, 0xa1, 0x55, 0x8c, 0x48,
|
||||
0xaf, 0xfc, 0xf8, 0x56, 0xa3, 0x2b, 0x96, 0xb2, 0xca, 0x2d, 0x5e, 0x5b, 0xe5, 0x6e, 0xf7, 0x6f,
|
||||
0xd7, 0x49, 0xa4, 0x55, 0x8d, 0x05, 0xa2, 0x45, 0xa9, 0x84, 0x64, 0xa0, 0x9a, 0x1c, 0x4c, 0x37,
|
||||
0xed, 0xea, 0x92, 0xe3, 0xed, 0x9d, 0x49, 0xc7, 0x6f, 0xb1, 0x9f, 0x80, 0x44, 0xe7, 0xf4, 0x89,
|
||||
0x47, 0x4e, 0x1d, 0xde, 0xeb, 0x71, 0xea, 0x30, 0x4c, 0xf6, 0xe2, 0xb3, 0xce, 0xd4, 0xc2, 0x70,
|
||||
0xbc, 0x7a, 0xdf, 0xc6, 0x61, 0x36, 0xc5, 0x43, 0x70, 0x16, 0x18, 0x76, 0xd6, 0x49, 0xc2, 0xdf,
|
||||
0xc8, 0xe4, 0xdb, 0xbf, 0x9c, 0x4f, 0x49, 0x66, 0xeb, 0xd3, 0xb0, 0x93, 0x9e, 0x25, 0xf2, 0x99,
|
||||
0xd6, 0x96, 0x46, 0xed, 0x73, 0x4d, 0xdc, 0x8e, 0xbd, 0x6b, 0x82, 0x44, 0x60, 0xd7, 0x5a, 0xbe,
|
||||
0x47, 0x6f, 0xe5, 0x89, 0xe8, 0xac, 0xde, 0x8a, 0xbf, 0x3e, 0x47, 0x7a, 0x88, 0xe2, 0x29, 0xdb,
|
||||
0x89, 0x8c, 0x00, 0x00, 0x3f, 0xf0, 0x00, 0xff, 0xc0, 0x03, 0xff, 0x00, 0x01, 0xdf, 0xf1, 0x31,
|
||||
0x00, 0x40, 0x0b, 0x01, 0x80, 0x80, 0xe0, 0x28, 0x08, 0x13, 0xff, 0x80, 0x07, 0xfe, 0x00, 0x1f,
|
||||
0xf8, 0x00, 0x7f, 0xf0, 0x0e, 0x05, 0x00, 0x01, 0x00, 0x2c, 0x07, 0x02, 0x03, 0x80, 0x00, 0x70,
|
||||
0x0c, 0x00, 0x3f, 0xf0, 0x00, 0xff, 0xc0, 0x03, 0xff, 0x00, 0x0f, 0xf7, 0x81, 0x40, 0x00, 0x40,
|
||||
0x0b, 0x01, 0x80, 0x81, 0x60, 0x00, 0x1c, 0x03, 0x00, 0x0f, 0xfc, 0x00, 0x3f, 0xf0, 0x00, 0xff,
|
||||
0xc0, 0x03, 0xfd, 0xe0, 0x50, 0x00, 0x10, 0x02, 0xc0, 0x70, 0x20, 0x58, 0x00, 0x07, 0x00, 0xc0,
|
||||
0x03, 0xff, 0x00, 0x0f, 0xfc, 0x00, 0x3f, 0xf0, 0x00, 0xff, 0x78, 0x14, 0x00, 0x04, 0x00, 0xb0,
|
||||
0x18, 0x08, 0x1e, 0x00, 0x01, 0xc0, 0x30, 0x00, 0xff, 0xc0, 0x03, 0xff, 0x00, 0x0f, 0xfc, 0x00,
|
||||
0x3f, 0xde, 0x05, 0x00, 0x01, 0x00, 0x2c, 0x07, 0x02, 0x07, 0x80, 0x00, 0x70, 0x0c, 0x00, 0x3f,
|
||||
0xf0, 0x00, 0xff, 0xc0, 0x03, 0xff, 0x00, 0x0f, 0xf7, 0x81, 0x40, 0x00, 0x40, 0x0b, 0x01, 0x80,
|
||||
0x82, 0x60, 0x00, 0x1c, 0x03, 0x00, 0x0f, 0xfc, 0x00, 0x3f, 0xf0, 0x00, 0xff, 0xc0, 0x03, 0xfd,
|
||||
0xe0, 0x50, 0x00, 0x10, 0x02, 0xc0, 0x70, 0x20, 0x98, 0x00, 0x07, 0x00, 0xc0, 0x03, 0xff, 0x00,
|
||||
0x0f, 0xfc, 0x00, 0x3f, 0xf0, 0x00, 0xff, 0x78, 0x14, 0x00, 0x04, 0x00, 0xb0, 0x18, 0x08, 0x2e,
|
||||
0x00, 0x01, 0xc0, 0x30, 0x00, 0xff, 0xc0, 0x03, 0xff, 0x00, 0x0f, 0xfc, 0x00, 0x3f, 0xde, 0x05,
|
||||
0x00, 0x01, 0x00, 0x2c, 0x07, 0x02, 0x0b, 0x80, 0x00, 0x70, 0x0c, 0x00, 0x3f, 0xf0, 0x00, 0xff,
|
||||
0xc0, 0x03, 0xff, 0x00, 0x0f, 0xf7, 0x81, 0x40, 0x00, 0x40, 0x0b, 0x01, 0x80, 0x83, 0x60, 0x00,
|
||||
0x1c, 0x03, 0x00, 0x0f, 0xfc, 0x00, 0x3f, 0xf0, 0x00, 0xff, 0xc0, 0x03, 0xfd, 0xe0, 0x50, 0x00,
|
||||
0x10, 0x02, 0xc0, 0x60, 0x20, 0xd8, 0x00, 0x07, 0x00, 0xc0, 0x03, 0xff, 0x00, 0x0f, 0xfc, 0x00,
|
||||
0x3f, 0xf0, 0x00, 0xff, 0x78, 0x14, 0x00, 0x04, 0x00, 0xb0, 0x18, 0x08, 0x36, 0x82, 0x52, 0x81,
|
||||
0x3f, 0xf8, 0x00, 0x7f, 0xe0, 0x01, 0x30, 0x78, 0x25, 0x20,
|
||||
};
|
||||
|
||||
// shrink: old 60000 B, new 57000 B, memory 131072 B
|
||||
static const uint32_t fx_shrink_mem = 131072;
|
||||
static const uint32_t fx_shrink_old = 60000;
|
||||
static const uint32_t fx_shrink_new = 57000;
|
||||
static const uint8_t fx_shrink_patch[356] = {
|
||||
0x14, 0x80, 0x80, 0x10, 0x80, 0x40, 0x80, 0xc0, 0x08, 0xa0, 0xa9, 0x07, 0xa8, 0xfa, 0x06, 0x77,
|
||||
0x80, 0x60, 0x28, 0x15, 0xa4, 0x02, 0xff, 0xc0, 0x03, 0xff, 0x00, 0x0f, 0xfc, 0x00, 0x3f, 0xb9,
|
||||
0xd0, 0x01, 0x80, 0x54, 0x20, 0x03, 0x00, 0xb0, 0x14, 0x0c, 0x05, 0x01, 0x02, 0xff, 0xf0, 0x00,
|
||||
0xff, 0xc0, 0x03, 0xff, 0x00, 0x0f, 0xe6, 0x54, 0x00, 0xc0, 0x2d, 0x14, 0x00, 0xc0, 0x2c, 0x06,
|
||||
0x02, 0x03, 0x80, 0xa0, 0x20, 0x7f, 0xfe, 0x00, 0x1f, 0xf8, 0x00, 0x7f, 0xe0, 0x01, 0xfb, 0x76,
|
||||
0x80, 0x24, 0x08, 0xa4, 0x00, 0x18, 0x05, 0x80, 0xe0, 0x40, 0x70, 0x14, 0x04, 0x12, 0xff, 0xc0,
|
||||
0x03, 0xff, 0x00, 0x0f, 0xfc, 0x00, 0x3f, 0x39, 0xd0, 0x06, 0x01, 0x74, 0xb0, 0x03, 0x00, 0xb0,
|
||||
0x18, 0x08, 0x16, 0x82, 0x70, 0x82, 0xbf, 0xf8, 0x00, 0x7f, 0xe0, 0x01, 0xff, 0x80, 0x04, 0x41,
|
||||
0xb8, 0x97, 0x68, 0x20, 0xe3, 0xa8, 0xe8, 0x72, 0x80, 0x3c, 0x0e, 0xa7, 0x0f, 0x40, 0x07, 0xee,
|
||||
0x81, 0x60, 0x28, 0x0b, 0xdb, 0xff, 0x80, 0x07, 0xfe, 0x00, 0x1f, 0xf8, 0x00, 0x7d, 0xb5, 0xa0,
|
||||
0x12, 0x04, 0x6a, 0x20, 0x06, 0x01, 0x6e, 0x35, 0xd0, 0x3c, 0x05, 0x01, 0x06, 0xff, 0xf0, 0x00,
|
||||
0xff, 0xc0, 0x03, 0xff, 0x00, 0x0f, 0xab, 0x54, 0x02, 0xa0, 0xa5, 0x50, 0x00, 0xc0, 0x2d, 0xc7,
|
||||
0xba, 0x07, 0x80, 0xa0, 0x20, 0xf7, 0xfe, 0x00, 0x1f, 0xf8, 0x00, 0x7f, 0xe0, 0x01, 0xf3, 0xcd,
|
||||
0x80, 0x60, 0x17, 0xab, 0x80, 0x18, 0x05, 0xb8, 0xd7, 0x41, 0x30, 0x14, 0x04, 0x21, 0xff, 0xc0,
|
||||
0x03, 0xff, 0x00, 0x0f, 0xfc, 0x00, 0x3e, 0x49, 0x50, 0x0d, 0x83, 0x55, 0xa0, 0x03, 0x00, 0xb7,
|
||||
0x1e, 0xe8, 0x26, 0x02, 0x80, 0x84, 0x9f, 0xf8, 0x00, 0x7f, 0xe0, 0x01, 0xff, 0x80, 0x07, 0xc3,
|
||||
0x36, 0x01, 0xe0, 0x76, 0xba, 0x00, 0x60, 0x16, 0xe3, 0x5d, 0x05, 0xc0, 0x50, 0x10, 0x9f, 0xff,
|
||||
0x00, 0x0f, 0xfc, 0x00, 0x3f, 0xf0, 0x00, 0xf7, 0xb6, 0xc0, 0x42, 0x10, 0x58, 0x00, 0x0c, 0x02,
|
||||
0xdc, 0x7b, 0xa0, 0xb8, 0x0a, 0x02, 0x15, 0x7f, 0xe0, 0x01, 0xff, 0x80, 0x07, 0xfe, 0x00, 0x1e,
|
||||
0xde, 0xa8, 0x09, 0x02, 0x3b, 0x18, 0x01, 0x80, 0x5b, 0x8d, 0x74, 0x1b, 0x01, 0x40, 0x42, 0xdf,
|
||||
0xfc, 0x00, 0x3f, 0xf0, 0x00, 0xff, 0xc0, 0x03, 0xd8, 0xe5, 0x01, 0x38, 0x4d, 0x66, 0x00, 0x30,
|
||||
0x0b, 0x71, 0xee, 0x83, 0x6a, 0x27, 0x48, 0x61, 0xff, 0x80, 0x07, 0xfe, 0x00, 0x1f, 0xf8, 0x00,
|
||||
0x55, 0x1e, 0x89, 0xd0,
|
||||
};
|
||||
|
||||
// same: old 60000 B, new 60000 B, memory 163840 B
|
||||
static const uint32_t fx_same_mem = 163840;
|
||||
static const uint32_t fx_same_old = 60000;
|
||||
static const uint32_t fx_same_new = 60000;
|
||||
static const uint8_t fx_same_patch[386] = {
|
||||
0x14, 0x80, 0x80, 0x14, 0x80, 0x40, 0x80, 0xc0, 0x0c, 0xa0, 0xa9, 0x07, 0xa0, 0xa9, 0x07, 0x77,
|
||||
0x80, 0x60, 0x28, 0x07, 0xd3, 0xf3, 0xf5, 0x5f, 0xab, 0xff, 0x00, 0x0f, 0xfc, 0x00, 0x3b, 0x7e,
|
||||
0xc8, 0x2f, 0x8b, 0xdd, 0xe8, 0x08, 0x02, 0x00, 0x58, 0x0a, 0x06, 0x02, 0x80, 0x8d, 0x1f, 0xf8,
|
||||
0x00, 0x7f, 0xe0, 0x01, 0xac, 0xf5, 0xd0, 0x03, 0xff, 0x00, 0x02, 0x97, 0xcb, 0x12, 0x00, 0x40,
|
||||
0x0b, 0x01, 0x80, 0x80, 0xe0, 0x28, 0x08, 0x13, 0xff, 0x80, 0x06, 0x25, 0x03, 0x40, 0x0f, 0xfc,
|
||||
0x00, 0x3f, 0xf0, 0x00, 0x3b, 0x3d, 0x92, 0x30, 0x04, 0x00, 0xb0, 0x1c, 0x08, 0x0e, 0x02, 0x80,
|
||||
0x5a, 0xb6, 0x5c, 0xfd, 0xb5, 0xbf, 0xf0, 0x00, 0xff, 0xc0, 0x03, 0xb7, 0xc3, 0x8b, 0xda, 0xf5,
|
||||
0xfa, 0x82, 0x80, 0x20, 0x05, 0x80, 0xc0, 0x40, 0xb0, 0x14, 0x05, 0x85, 0xff, 0xc0, 0x03, 0xff,
|
||||
0x00, 0x08, 0xf6, 0x76, 0x80, 0x1f, 0xf8, 0x00, 0x38, 0x3c, 0x18, 0xb8, 0x02, 0x00, 0x58, 0x0e,
|
||||
0x04, 0x0b, 0x01, 0x40, 0x40, 0x9f, 0xfc, 0x00, 0x1f, 0x6a, 0x1a, 0x00, 0x7f, 0xe0, 0x01, 0xff,
|
||||
0x80, 0x04, 0x11, 0xc8, 0x94, 0x00, 0x20, 0x05, 0x80, 0xc0, 0x40, 0xf0, 0x14, 0x01, 0xb9, 0x6b,
|
||||
0xe3, 0x6b, 0x75, 0xff, 0x80, 0x07, 0xfe, 0x00, 0x1d, 0xbc, 0xe4, 0xa5, 0xe9, 0x6e, 0xb4, 0x28,
|
||||
0x01, 0x00, 0x2c, 0x07, 0x02, 0x07, 0x80, 0xa0, 0x35, 0x0f, 0xfe, 0x00, 0x1f, 0xf8, 0x00, 0x24,
|
||||
0x3a, 0x34, 0x00, 0xff, 0xc0, 0x02, 0xdd, 0xee, 0xc6, 0xc0, 0x10, 0x02, 0xc0, 0x60, 0x20, 0x98,
|
||||
0x0a, 0x02, 0x04, 0xff, 0xe0, 0x00, 0x6d, 0x51, 0xd0, 0x03, 0xff, 0x00, 0x0f, 0xfc, 0x00, 0x32,
|
||||
0x4f, 0x24, 0xb0, 0x01, 0x00, 0x2c, 0x07, 0x02, 0x09, 0x80, 0xa0, 0x04, 0xe9, 0x27, 0x71, 0x49,
|
||||
0xef, 0xfc, 0x00, 0x3f, 0xf0, 0x00, 0xed, 0xf9, 0x67, 0x67, 0xd9, 0x7c, 0xa1, 0xc0, 0x08, 0x01,
|
||||
0x60, 0x30, 0x10, 0x5c, 0x05, 0x01, 0xef, 0x7f, 0xf0, 0x00, 0xff, 0xc0, 0x00, 0x05, 0x89, 0xa0,
|
||||
0x07, 0xfe, 0x00, 0x1f, 0xcf, 0xe6, 0x3e, 0x00, 0x80, 0x16, 0x03, 0x81, 0x05, 0xc0, 0x50, 0x0f,
|
||||
0x23, 0xbe, 0xdc, 0xbe, 0x4f, 0xfe, 0x00, 0x1f, 0xf8, 0x00, 0x7f, 0xe0, 0x00, 0x20, 0x70, 0x26,
|
||||
0x20, 0x08, 0x01, 0x60, 0x30, 0x10, 0x6c, 0x05, 0x01, 0x02, 0x7f, 0xf0, 0x00, 0xff, 0xc0, 0x03,
|
||||
0xff, 0x00, 0x0f, 0xfe, 0x01, 0xc0, 0xa0, 0x00, 0x20, 0x05, 0x80, 0xe0, 0x41, 0xb0, 0x00, 0x0e,
|
||||
0x01, 0x80, 0x07, 0xfe, 0x00, 0x1f, 0xf8, 0x00, 0x7f, 0xe0, 0x01, 0xfe, 0xf0, 0x28, 0x00, 0x08,
|
||||
0x01, 0x60, 0x30, 0x10, 0x7d, 0x04, 0xa5, 0x02, 0x7f, 0xf0, 0x00, 0xff, 0xc0, 0x02, 0x60, 0xf0,
|
||||
0x4a, 0x40,
|
||||
};
|
||||
@@ -0,0 +1,212 @@
|
||||
// CUSTOM (TeTeHacko): FwPatch (in-place delta update) against a fake flash.
|
||||
// The patches come from tools/ota_fixtures.py; the images are rebuilt here with
|
||||
// the same generator, so the header only carries a few kB of patch bytes.
|
||||
|
||||
#include "fixtures.h"
|
||||
#include "helpers/FwPatch.h"
|
||||
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <gtest/gtest.h>
|
||||
#include <vector>
|
||||
|
||||
namespace {
|
||||
|
||||
std::vector<uint8_t> xorshift(uint32_t x, size_t n) {
|
||||
std::vector<uint8_t> out(n);
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
x ^= x << 13;
|
||||
x ^= x >> 17;
|
||||
x ^= x << 5;
|
||||
out[i] = (uint8_t)(x & 0xFF);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
void make_images(const char *c, std::vector<uint8_t> &old_img, std::vector<uint8_t> &new_img) {
|
||||
old_img = xorshift(0x12345678u, 60000);
|
||||
if (!strcmp(c, "grow")) {
|
||||
auto ins = xorshift(0xCAFEBABEu, 8192);
|
||||
new_img.assign(old_img.begin(), old_img.begin() + 5000);
|
||||
new_img.insert(new_img.end(), ins.begin(), ins.end());
|
||||
new_img.insert(new_img.end(), old_img.begin() + 5000, old_img.end());
|
||||
} else if (!strcmp(c, "shrink")) {
|
||||
new_img.assign(old_img.begin(), old_img.begin() + 20000);
|
||||
new_img.insert(new_img.end(), old_img.begin() + 23000, old_img.end());
|
||||
for (size_t i = 0; i < new_img.size(); i += 4093)
|
||||
new_img[i] ^= 0x5A;
|
||||
} else {
|
||||
new_img = old_img;
|
||||
for (int i = 0; i < 16; i++)
|
||||
new_img[1000 + i * 3001] ^= 0xFF;
|
||||
}
|
||||
}
|
||||
|
||||
// Fake flash: page-aligned, erase = 0xFF, write = AND (what NOR flash does).
|
||||
struct Flash {
|
||||
uint8_t *mem;
|
||||
uint32_t size;
|
||||
Flash(uint32_t n) : size(n) {
|
||||
mem = (uint8_t *)aligned_alloc(FWP_PAGE, n);
|
||||
memset(mem, 0xFF, n);
|
||||
}
|
||||
~Flash() { free(mem); }
|
||||
};
|
||||
|
||||
std::vector<uint8_t> g_sink;
|
||||
int g_ticks;
|
||||
void sink(void *, const uint8_t *p, uint32_t n) {
|
||||
g_sink.insert(g_sink.end(), p, p + n);
|
||||
}
|
||||
void erase_page(uintptr_t a) {
|
||||
memset((void *)a, 0xFF, FWP_PAGE);
|
||||
}
|
||||
void write_page(uintptr_t a, const uint8_t *s, uint32_t n) {
|
||||
uint8_t *d = (uint8_t *)a;
|
||||
for (uint32_t i = 0; i < n; i++)
|
||||
d[i] &= s[i];
|
||||
}
|
||||
void tick() {
|
||||
g_ticks++;
|
||||
}
|
||||
|
||||
fwp_job job(Flash &f, uint32_t from, const uint8_t *p, uint32_t pn, bool dry) {
|
||||
fwp_job j;
|
||||
memset(&j, 0, sizeof(j));
|
||||
j.mem_base = (uintptr_t)f.mem;
|
||||
j.mem_size = f.size;
|
||||
j.from_size = from;
|
||||
j.patch = p;
|
||||
j.patch_size = pn;
|
||||
j.dry = dry;
|
||||
j.sink = sink;
|
||||
j.erase = erase_page;
|
||||
j.write = write_page;
|
||||
j.tick = tick;
|
||||
return j;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
struct Case {
|
||||
const char *name;
|
||||
uint32_t mem;
|
||||
const uint8_t *patch;
|
||||
uint32_t patch_size;
|
||||
};
|
||||
|
||||
static const Case kCases[] = {
|
||||
{ "grow", fx_grow_mem, fx_grow_patch, sizeof(fx_grow_patch) },
|
||||
{ "shrink", fx_shrink_mem, fx_shrink_patch, sizeof(fx_shrink_patch) },
|
||||
{ "same", fx_same_mem, fx_same_patch, sizeof(fx_same_patch) },
|
||||
};
|
||||
|
||||
|
||||
class FwPatchCase : public ::testing::TestWithParam<Case> {};
|
||||
|
||||
// The dry run predicts the image exactly and leaves the flash alone; the real
|
||||
// run then writes exactly that image.
|
||||
TEST_P(FwPatchCase, DryPredictsRealAndFlashUntouched) {
|
||||
const Case &c = GetParam();
|
||||
std::vector<uint8_t> o, n;
|
||||
make_images(c.name, o, n);
|
||||
Flash f(c.mem);
|
||||
memcpy(f.mem, o.data(), o.size());
|
||||
// stale bytes after the image, as a real flash has after a bigger old image
|
||||
for (uint32_t i = o.size(); i < o.size() + 3000 && i < f.size; i++)
|
||||
f.mem[i] = (uint8_t)(i * 7);
|
||||
std::vector<uint8_t> before(f.mem, f.mem + f.size);
|
||||
|
||||
g_sink.clear();
|
||||
fwp_job d = job(f, o.size(), c.patch, c.patch_size, true);
|
||||
ASSERT_EQ(fwp_run(&d), 0) << "detools " << d.detools_err;
|
||||
EXPECT_EQ(d.to_size, n.size());
|
||||
EXPECT_TRUE(g_sink == n);
|
||||
EXPECT_EQ(memcmp(before.data(), f.mem, f.size), 0) << "dry run touched the flash";
|
||||
|
||||
g_ticks = 0;
|
||||
fwp_job r = job(f, o.size(), c.patch, c.patch_size, false);
|
||||
ASSERT_EQ(fwp_run(&r), 0) << "detools " << r.detools_err;
|
||||
EXPECT_EQ(memcmp(f.mem, n.data(), n.size()), 0);
|
||||
EXPECT_GT(g_ticks, 0);
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(Fixtures, FwPatchCase, ::testing::ValuesIn(kCases),
|
||||
[](const ::testing::TestParamInfo<Case> &i) { return std::string(i.param.name); });
|
||||
|
||||
// The overlap case must really exercise the overlap, otherwise the test above
|
||||
// proves less than it claims.
|
||||
TEST(FwPatch, GrowCaseOverlapsShiftedAndNewImage) {
|
||||
uint32_t mem, seg, shift, from, to;
|
||||
ASSERT_EQ(fwp_header(fx_grow_patch, sizeof(fx_grow_patch), &mem, &seg, &shift, &from, &to), 0);
|
||||
EXPECT_EQ(seg, FWP_PAGE);
|
||||
EXPECT_LT(shift + 0u, to) << "shifted old image and new image do not overlap";
|
||||
EXPECT_LE(shift + from, mem);
|
||||
}
|
||||
|
||||
// A wrong base still runs (detools cannot know), but the result differs -- the
|
||||
// signed hash in FwUpdate is what rejects it. The dry run must still not touch
|
||||
// the flash, and must predict the real run.
|
||||
TEST(FwPatch, WrongBaseGivesDifferentImageDryStillPredictsReal) {
|
||||
std::vector<uint8_t> o, n;
|
||||
make_images("same", o, n);
|
||||
o[30000] ^= 0x01;
|
||||
Flash f(fx_same_mem);
|
||||
memcpy(f.mem, o.data(), o.size());
|
||||
g_sink.clear();
|
||||
fwp_job d = job(f, o.size(), fx_same_patch, sizeof(fx_same_patch), true);
|
||||
ASSERT_EQ(fwp_run(&d), 0);
|
||||
EXPECT_FALSE(g_sink == n);
|
||||
std::vector<uint8_t> predicted = g_sink;
|
||||
fwp_job r = job(f, o.size(), fx_same_patch, sizeof(fx_same_patch), false);
|
||||
ASSERT_EQ(fwp_run(&r), 0);
|
||||
EXPECT_EQ(memcmp(f.mem, predicted.data(), predicted.size()), 0);
|
||||
}
|
||||
|
||||
TEST(FwPatch, SizeMismatchRejectedBeforeAnything) {
|
||||
Flash f(fx_same_mem);
|
||||
g_sink.clear();
|
||||
fwp_job d = job(f, fx_same_old + 4, fx_same_patch, sizeof(fx_same_patch), true);
|
||||
EXPECT_EQ(fwp_run(&d), FWP_ERR_SIZE);
|
||||
fwp_job m = job(f, fx_same_old, fx_same_patch, sizeof(fx_same_patch), true);
|
||||
m.mem_size += FWP_PAGE;
|
||||
EXPECT_EQ(fwp_run(&m), FWP_ERR_SIZE);
|
||||
}
|
||||
|
||||
// Corrupted patches: whatever detools makes of them, the dry run never touches
|
||||
// the flash and, when it succeeds, the real run writes exactly its prediction.
|
||||
TEST(FwPatch, CorruptedPatchesDryAlwaysPredictsReal) {
|
||||
std::vector<uint8_t> o, n;
|
||||
make_images("grow", o, n);
|
||||
std::vector<uint8_t> p(fx_grow_patch, fx_grow_patch + sizeof(fx_grow_patch));
|
||||
uint32_t x = 1;
|
||||
int accepted = 0;
|
||||
for (int it = 0; it < 200; it++) {
|
||||
std::vector<uint8_t> q = p;
|
||||
for (int k = 0; k < 2; k++) {
|
||||
x ^= x << 13;
|
||||
x ^= x >> 17;
|
||||
x ^= x << 5;
|
||||
q[16 + x % (q.size() - 16)] ^= (uint8_t)(1 + (x >> 8) % 255); // keep the header
|
||||
}
|
||||
Flash f(fx_grow_mem);
|
||||
memcpy(f.mem, o.data(), o.size());
|
||||
std::vector<uint8_t> before(f.mem, f.mem + f.size);
|
||||
g_sink.clear();
|
||||
fwp_job d = job(f, o.size(), q.data(), q.size(), true);
|
||||
int rd = fwp_run(&d);
|
||||
ASSERT_EQ(memcmp(before.data(), f.mem, f.size), 0) << "dry run touched the flash, it " << it;
|
||||
if (rd != 0) continue;
|
||||
accepted++;
|
||||
std::vector<uint8_t> predicted = g_sink;
|
||||
fwp_job r = job(f, o.size(), q.data(), q.size(), false);
|
||||
ASSERT_EQ(fwp_run(&r), 0) << "it " << it;
|
||||
ASSERT_EQ(memcmp(f.mem, predicted.data(), predicted.size()), 0) << "it " << it;
|
||||
}
|
||||
RecordProperty("accepted", accepted);
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
Reference in new issue
Block a user